1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 package org.apache.commons.lang3;
18
19 import static org.junit.Assert.*;
20
21 import java.lang.reflect.Constructor;
22 import java.lang.reflect.Modifier;
23 import java.util.Arrays;
24 import java.util.Comparator;
25 import java.util.Date;
26 import java.util.Map;
27
28 import org.junit.Test;
29
30
31
32
33
34
35 @SuppressWarnings("deprecation")
36 public class ArrayUtilsTest {
37
38
39 @Test
40 public void testConstructor() {
41 assertNotNull(new ArrayUtils());
42 final Constructor<?>[] cons = ArrayUtils.class.getDeclaredConstructors();
43 assertEquals(1, cons.length);
44 assertTrue(Modifier.isPublic(cons[0].getModifiers()));
45 assertTrue(Modifier.isPublic(ArrayUtils.class.getModifiers()));
46 assertFalse(Modifier.isFinal(ArrayUtils.class.getModifiers()));
47 }
48
49
50 @Test
51 public void testToString() {
52 assertEquals("{}", ArrayUtils.toString(null));
53 assertEquals("{}", ArrayUtils.toString(new Object[0]));
54 assertEquals("{}", ArrayUtils.toString(new String[0]));
55 assertEquals("{<null>}", ArrayUtils.toString(new String[] {null}));
56 assertEquals("{pink,blue}", ArrayUtils.toString(new String[] {"pink","blue"}));
57
58 assertEquals("<empty>", ArrayUtils.toString(null, "<empty>"));
59 assertEquals("{}", ArrayUtils.toString(new Object[0], "<empty>"));
60 assertEquals("{}", ArrayUtils.toString(new String[0], "<empty>"));
61 assertEquals("{<null>}", ArrayUtils.toString(new String[] {null}, "<empty>"));
62 assertEquals("{pink,blue}", ArrayUtils.toString(new String[] {"pink","blue"}, "<empty>"));
63 }
64
65
66 @Test
67 public void testHashCode() {
68 final long[][] array1 = new long[][] {{2,5}, {4,5}};
69 final long[][] array2 = new long[][] {{2,5}, {4,6}};
70 assertTrue(ArrayUtils.hashCode(array1) == ArrayUtils.hashCode(array1));
71 assertFalse(ArrayUtils.hashCode(array1) == ArrayUtils.hashCode(array2));
72
73 final Object[] array3 = new Object[] {new String(new char[] {'A', 'B'})};
74 final Object[] array4 = new Object[] {"AB"};
75 assertTrue(ArrayUtils.hashCode(array3) == ArrayUtils.hashCode(array3));
76 assertTrue(ArrayUtils.hashCode(array3) == ArrayUtils.hashCode(array4));
77
78 final Object[] arrayA = new Object[] {new boolean[] {true, false}, new int[] {6, 7}};
79 final Object[] arrayB = new Object[] {new boolean[] {true, false}, new int[] {6, 7}};
80 assertTrue(ArrayUtils.hashCode(arrayB) == ArrayUtils.hashCode(arrayA));
81 }
82
83
84 private void assertIsEquals(final Object array1, final Object array2, final Object array3) {
85 assertTrue(ArrayUtils.isEquals(array1, array1));
86 assertTrue(ArrayUtils.isEquals(array2, array2));
87 assertTrue(ArrayUtils.isEquals(array3, array3));
88 assertFalse(ArrayUtils.isEquals(array1, array2));
89 assertFalse(ArrayUtils.isEquals(array2, array1));
90 assertFalse(ArrayUtils.isEquals(array1, array3));
91 assertFalse(ArrayUtils.isEquals(array3, array1));
92 assertFalse(ArrayUtils.isEquals(array1, array2));
93 assertFalse(ArrayUtils.isEquals(array2, array1));
94 }
95
96 @Test
97 public void testIsEquals() {
98 final long[][] larray1 = new long[][]{{2, 5}, {4, 5}};
99 final long[][] larray2 = new long[][]{{2, 5}, {4, 6}};
100 final long[] larray3 = new long[]{2, 5};
101 this.assertIsEquals(larray1, larray2, larray3);
102
103 final int[][] iarray1 = new int[][]{{2, 5}, {4, 5}};
104 final int[][] iarray2 = new int[][]{{2, 5}, {4, 6}};
105 final int[] iarray3 = new int[]{2, 5};
106 this.assertIsEquals(iarray1, iarray2, iarray3);
107
108 final short[][] sarray1 = new short[][]{{2, 5}, {4, 5}};
109 final short[][] sarray2 = new short[][]{{2, 5}, {4, 6}};
110 final short[] sarray3 = new short[]{2, 5};
111 this.assertIsEquals(sarray1, sarray2, sarray3);
112
113 final float[][] farray1 = new float[][]{{2, 5}, {4, 5}};
114 final float[][] farray2 = new float[][]{{2, 5}, {4, 6}};
115 final float[] farray3 = new float[]{2, 5};
116 this.assertIsEquals(farray1, farray2, farray3);
117
118 final double[][] darray1 = new double[][]{{2, 5}, {4, 5}};
119 final double[][] darray2 = new double[][]{{2, 5}, {4, 6}};
120 final double[] darray3 = new double[]{2, 5};
121 this.assertIsEquals(darray1, darray2, darray3);
122
123 final byte[][] byteArray1 = new byte[][]{{2, 5}, {4, 5}};
124 final byte[][] byteArray2 = new byte[][]{{2, 5}, {4, 6}};
125 final byte[] byteArray3 = new byte[]{2, 5};
126 this.assertIsEquals(byteArray1, byteArray2, byteArray3);
127
128 final char[][] charArray1 = new char[][]{{2, 5}, {4, 5}};
129 final char[][] charArray2 = new char[][]{{2, 5}, {4, 6}};
130 final char[] charArray3 = new char[]{2, 5};
131 this.assertIsEquals(charArray1, charArray2, charArray3);
132
133 final boolean[][] barray1 = new boolean[][]{{true, false}, {true, true}};
134 final boolean[][] barray2 = new boolean[][]{{true, false}, {true, false}};
135 final boolean[] barray3 = new boolean[]{false, true};
136 this.assertIsEquals(barray1, barray2, barray3);
137
138 final Object[] array3 = new Object[]{new String(new char[]{'A', 'B'})};
139 final Object[] array4 = new Object[]{"AB"};
140 assertTrue(ArrayUtils.isEquals(array3, array3));
141 assertTrue(ArrayUtils.isEquals(array3, array4));
142
143 assertTrue(ArrayUtils.isEquals(null, null));
144 assertFalse(ArrayUtils.isEquals(null, array4));
145 }
146
147
148
149
150
151 @Test
152 public void testArrayCreation()
153 {
154 final String[] array = ArrayUtils.toArray("foo", "bar");
155 assertEquals(2, array.length);
156 assertEquals("foo", array[0]);
157 assertEquals("bar", array[1]);
158 }
159
160
161
162
163 @Test
164 public void testArrayCreationWithGeneralReturnType()
165 {
166 final Object obj = ArrayUtils.toArray("foo", "bar");
167 assertTrue(obj instanceof String[]);
168 }
169
170
171
172
173 @Test
174 public void testArrayCreationWithDifferentTypes()
175 {
176 final Number[] array = ArrayUtils.<Number>toArray(Integer.valueOf(42), Double.valueOf(Math.PI));
177 assertEquals(2, array.length);
178 assertEquals(Integer.valueOf(42), array[0]);
179 assertEquals(Double.valueOf(Math.PI), array[1]);
180 }
181
182
183
184
185 @Test
186 public void testIndirectArrayCreation()
187 {
188 final String[] array = toArrayPropagatingType("foo", "bar");
189 assertEquals(2, array.length);
190 assertEquals("foo", array[0]);
191 assertEquals("bar", array[1]);
192 }
193
194
195
196
197 @Test
198 public void testEmptyArrayCreation()
199 {
200 final String[] array = ArrayUtils.<String>toArray();
201 assertEquals(0, array.length);
202 }
203
204
205
206
207 @Test
208 public void testIndirectEmptyArrayCreation()
209 {
210 final String[] array = ArrayUtilsTest.<String>toArrayPropagatingType();
211 assertEquals(0, array.length);
212 }
213
214 private static <T> T[] toArrayPropagatingType(final T... items)
215 {
216 return ArrayUtils.toArray(items);
217 }
218
219
220 @Test
221 public void testToMap() {
222 Map<?, ?> map = ArrayUtils.toMap(new String[][] {{"foo", "bar"}, {"hello", "world"}});
223
224 assertEquals("bar", map.get("foo"));
225 assertEquals("world", map.get("hello"));
226
227 assertEquals(null, ArrayUtils.toMap(null));
228 try {
229 ArrayUtils.toMap(new String[][] {{"foo", "bar"}, {"short"}});
230 fail("exception expected");
231 } catch (final IllegalArgumentException ex) {}
232 try {
233 ArrayUtils.toMap(new Object[] {new Object[] {"foo", "bar"}, "illegal type"});
234 fail("exception expected");
235 } catch (final IllegalArgumentException ex) {}
236 try {
237 ArrayUtils.toMap(new Object[] {new Object[] {"foo", "bar"}, null});
238 fail("exception expected");
239 } catch (final IllegalArgumentException ex) {}
240
241 map = ArrayUtils.toMap(new Object[] {new Map.Entry<Object, Object>() {
242 @Override
243 public Object getKey() {
244 return "foo";
245 }
246 @Override
247 public Object getValue() {
248 return "bar";
249 }
250 @Override
251 public Object setValue(final Object value) {
252 throw new UnsupportedOperationException();
253 }
254 @Override
255 public boolean equals(final Object o) {
256 throw new UnsupportedOperationException();
257 }
258 @Override
259 public int hashCode() {
260 throw new UnsupportedOperationException();
261 }
262 }});
263 assertEquals("bar", map.get("foo"));
264 }
265
266
267 @Test
268 public void testClone() {
269 assertArrayEquals(null, ArrayUtils.clone((Object[]) null));
270 Object[] original1 = new Object[0];
271 Object[] cloned1 = ArrayUtils.clone(original1);
272 assertTrue(Arrays.equals(original1, cloned1));
273 assertTrue(original1 != cloned1);
274
275 final StringBuffer buf = new StringBuffer("pick");
276 original1 = new Object[] {buf, "a", new String[] {"stick"}};
277 cloned1 = ArrayUtils.clone(original1);
278 assertTrue(Arrays.equals(original1, cloned1));
279 assertTrue(original1 != cloned1);
280 assertSame(original1[0], cloned1[0]);
281 assertSame(original1[1], cloned1[1]);
282 assertSame(original1[2], cloned1[2]);
283 }
284
285 @Test
286 public void testCloneBoolean() {
287 assertEquals(null, ArrayUtils.clone((boolean[]) null));
288 final boolean[] original = new boolean[] {true, false};
289 final boolean[] cloned = ArrayUtils.clone(original);
290 assertTrue(Arrays.equals(original, cloned));
291 assertTrue(original != cloned);
292 }
293
294 @Test
295 public void testCloneLong() {
296 assertEquals(null, ArrayUtils.clone((long[]) null));
297 final long[] original = new long[] {0L, 1L};
298 final long[] cloned = ArrayUtils.clone(original);
299 assertTrue(Arrays.equals(original, cloned));
300 assertTrue(original != cloned);
301 }
302
303 @Test
304 public void testCloneInt() {
305 assertEquals(null, ArrayUtils.clone((int[]) null));
306 final int[] original = new int[] {5, 8};
307 final int[] cloned = ArrayUtils.clone(original);
308 assertTrue(Arrays.equals(original, cloned));
309 assertTrue(original != cloned);
310 }
311
312 @Test
313 public void testCloneShort() {
314 assertEquals(null, ArrayUtils.clone((short[]) null));
315 final short[] original = new short[] {1, 4};
316 final short[] cloned = ArrayUtils.clone(original);
317 assertTrue(Arrays.equals(original, cloned));
318 assertTrue(original != cloned);
319 }
320
321 @Test
322 public void testCloneChar() {
323 assertEquals(null, ArrayUtils.clone((char[]) null));
324 final char[] original = new char[] {'a', '4'};
325 final char[] cloned = ArrayUtils.clone(original);
326 assertTrue(Arrays.equals(original, cloned));
327 assertTrue(original != cloned);
328 }
329
330 @Test
331 public void testCloneByte() {
332 assertEquals(null, ArrayUtils.clone((byte[]) null));
333 final byte[] original = new byte[] {1, 6};
334 final byte[] cloned = ArrayUtils.clone(original);
335 assertTrue(Arrays.equals(original, cloned));
336 assertTrue(original != cloned);
337 }
338
339 @Test
340 public void testCloneDouble() {
341 assertEquals(null, ArrayUtils.clone((double[]) null));
342 final double[] original = new double[] {2.4d, 5.7d};
343 final double[] cloned = ArrayUtils.clone(original);
344 assertTrue(Arrays.equals(original, cloned));
345 assertTrue(original != cloned);
346 }
347
348 @Test
349 public void testCloneFloat() {
350 assertEquals(null, ArrayUtils.clone((float[]) null));
351 final float[] original = new float[] {2.6f, 6.4f};
352 final float[] cloned = ArrayUtils.clone(original);
353 assertTrue(Arrays.equals(original, cloned));
354 assertTrue(original != cloned);
355 }
356
357
358
359
360 @Test
361 public void testNullToEmptyBooleanNull() throws Exception {
362 assertEquals(ArrayUtils.EMPTY_BOOLEAN_ARRAY, ArrayUtils.nullToEmpty((boolean[]) null));
363 }
364
365 @Test
366 public void testNullToEmptyBooleanEmptyArray() throws Exception {
367 final boolean[] empty = new boolean[]{};
368 final boolean[] result = ArrayUtils.nullToEmpty(empty);
369 assertEquals(ArrayUtils.EMPTY_BOOLEAN_ARRAY, result);
370 assertNotSame(empty, result);
371 }
372
373 @Test
374 public void testNullToEmptyBoolean() {
375 final boolean[] original = new boolean[] {true, false};
376 assertEquals(original, ArrayUtils.nullToEmpty(original));
377 }
378
379 @Test
380 public void testNullToEmptyLongNull() throws Exception {
381 assertEquals(ArrayUtils.EMPTY_LONG_ARRAY, ArrayUtils.nullToEmpty((long[]) null));
382 }
383
384 @Test
385 public void testNullToEmptyLongEmptyArray() throws Exception {
386 final long[] empty = new long[]{};
387 final long[] result = ArrayUtils.nullToEmpty(empty);
388 assertEquals(ArrayUtils.EMPTY_LONG_ARRAY, result);
389 assertNotSame(empty, result);
390 }
391
392 @Test
393 public void testNullToEmptyLong() {
394 final long[] original = new long[] {1L, 2L};
395 assertEquals(original, ArrayUtils.nullToEmpty(original));
396 }
397
398 @Test
399 public void testNullToEmptyIntNull() throws Exception {
400 assertEquals(ArrayUtils.EMPTY_INT_ARRAY, ArrayUtils.nullToEmpty((int[]) null));
401 }
402
403 @Test
404 public void testNullToEmptyIntEmptyArray() throws Exception {
405 final int[] empty = new int[]{};
406 final int[] result = ArrayUtils.nullToEmpty(empty);
407 assertEquals(ArrayUtils.EMPTY_INT_ARRAY, result);
408 assertNotSame(empty, result);
409 }
410
411 @Test
412 public void testNullToEmptyInt() {
413 final int[] original = new int[] {1, 2};
414 assertEquals(original, ArrayUtils.nullToEmpty(original));
415 }
416
417 @Test
418 public void testNullToEmptyShortNull() throws Exception {
419 assertEquals(ArrayUtils.EMPTY_SHORT_ARRAY, ArrayUtils.nullToEmpty((short[]) null));
420 }
421
422 @Test
423 public void testNullToEmptyShortEmptyArray() throws Exception {
424 final short[] empty = new short[]{};
425 final short[] result = ArrayUtils.nullToEmpty(empty);
426 assertEquals(ArrayUtils.EMPTY_SHORT_ARRAY, result);
427 assertNotSame(empty, result);
428 }
429
430 @Test
431 public void testNullToEmptyShort() {
432 final short[] original = new short[] {1, 2};
433 assertEquals(original, ArrayUtils.nullToEmpty(original));
434 }
435
436 @Test
437 public void testNullToEmptyCharNull() throws Exception {
438 assertEquals(ArrayUtils.EMPTY_CHAR_ARRAY, ArrayUtils.nullToEmpty((char[]) null));
439 }
440
441 @Test
442 public void testNullToEmptyCharEmptyArray() throws Exception {
443 final char[] empty = new char[]{};
444 final char[] result = ArrayUtils.nullToEmpty(empty);
445 assertEquals(ArrayUtils.EMPTY_CHAR_ARRAY, result);
446 assertNotSame(empty, result);
447 }
448
449 @Test
450 public void testNullToEmptyChar() {
451 final char[] original = new char[] {'a', 'b'};
452 assertEquals(original, ArrayUtils.nullToEmpty(original));
453 }
454
455 @Test
456 public void testNullToEmptyByteNull() throws Exception {
457 assertEquals(ArrayUtils.EMPTY_BYTE_ARRAY, ArrayUtils.nullToEmpty((byte[]) null));
458 }
459
460 @Test
461 public void testNullToEmptyByteEmptyArray() throws Exception {
462 final byte[] empty = new byte[]{};
463 final byte[] result = ArrayUtils.nullToEmpty(empty);
464 assertEquals(ArrayUtils.EMPTY_BYTE_ARRAY, result);
465 assertNotSame(empty, result);
466 }
467
468 @Test
469 public void testNullToEmptyByte() {
470 final byte[] original = new byte[] {0x0F, 0x0E};
471 assertEquals(original, ArrayUtils.nullToEmpty(original));
472 }
473
474 @Test
475 public void testNullToEmptyDoubleNull() throws Exception {
476 assertEquals(ArrayUtils.EMPTY_DOUBLE_ARRAY, ArrayUtils.nullToEmpty((double[]) null));
477 }
478
479 @Test
480 public void testNullToEmptyDoubleEmptyArray() throws Exception {
481 final double[] empty = new double[]{};
482 final double[] result = ArrayUtils.nullToEmpty(empty);
483 assertEquals(ArrayUtils.EMPTY_DOUBLE_ARRAY, result);
484 assertNotSame(empty, result);
485 }
486
487 @Test
488 public void testNullToEmptyDouble() {
489 final double[] original = new double[] {1L, 2L};
490 assertEquals(original, ArrayUtils.nullToEmpty(original));
491 }
492
493 @Test
494 public void testNullToEmptyFloatNull() throws Exception {
495 assertEquals(ArrayUtils.EMPTY_FLOAT_ARRAY, ArrayUtils.nullToEmpty((float[]) null));
496 }
497
498 @Test
499 public void testNullToEmptyFloatEmptyArray() throws Exception {
500 final float[] empty = new float[]{};
501 final float[] result = ArrayUtils.nullToEmpty(empty);
502 assertEquals(ArrayUtils.EMPTY_FLOAT_ARRAY, result);
503 assertNotSame(empty, result);
504 }
505
506 @Test
507 public void testNullToEmptyFloat() {
508 final float[] original = new float[] {2.6f, 3.8f};
509 assertEquals(original, ArrayUtils.nullToEmpty(original));
510 }
511
512 @Test
513 public void testNullToEmptyObjectNull() throws Exception {
514 assertArrayEquals(ArrayUtils.EMPTY_OBJECT_ARRAY, ArrayUtils.nullToEmpty((Object[]) null));
515 }
516
517 @Test
518 public void testNullToEmptyObjectEmptyArray() throws Exception {
519 final Object[] empty = new Object[]{};
520 final Object[] result = ArrayUtils.nullToEmpty(empty);
521 assertArrayEquals(ArrayUtils.EMPTY_OBJECT_ARRAY, result);
522 assertNotSame(empty, result);
523 }
524
525 @Test
526 public void testNullToEmptyObject() {
527 final Object[] original = new Object[] {Boolean.TRUE, Boolean.FALSE};
528 assertArrayEquals(original, ArrayUtils.nullToEmpty(original));
529 }
530
531 @Test
532 public void testNullToEmptyClassNull() throws Exception {
533 assertArrayEquals(ArrayUtils.EMPTY_CLASS_ARRAY, ArrayUtils.nullToEmpty((Class<?>[]) null));
534 }
535
536 @Test
537 public void testNullToEmptyClassEmptyArray() throws Exception {
538 final Class<?>[] empty = {};
539 final Class<?>[] result = ArrayUtils.nullToEmpty(empty);
540 assertArrayEquals(ArrayUtils.EMPTY_CLASS_ARRAY, result);
541 assertNotSame(empty, result);
542 }
543
544 @Test
545 public void testNullToEmptyClass() {
546 final Class<?>[] original = { Object.class, String.class };
547 assertArrayEquals(original, ArrayUtils.nullToEmpty(original));
548 }
549
550 @Test
551 public void testNullToEmptyStringNull() throws Exception {
552 assertArrayEquals(ArrayUtils.EMPTY_STRING_ARRAY, ArrayUtils.nullToEmpty((String[]) null));
553 }
554
555 @Test
556 public void testNullToEmptyStringEmptyArray() throws Exception {
557 final String[] empty = new String[]{};
558 final String[] result = ArrayUtils.nullToEmpty(empty);
559 assertArrayEquals(ArrayUtils.EMPTY_STRING_ARRAY, result);
560 assertNotSame(empty, result);
561 }
562
563 @Test
564 public void testNullToEmptyString() {
565 final String[] original = new String[] {"abc", "def"};
566 assertArrayEquals(original, ArrayUtils.nullToEmpty(original));
567 }
568
569 @Test
570 public void testNullToEmptyBooleanObjectNull() throws Exception {
571 assertArrayEquals(ArrayUtils.EMPTY_BOOLEAN_OBJECT_ARRAY, ArrayUtils.nullToEmpty((Boolean[]) null));
572 }
573
574 @Test
575 public void testNullToEmptyBooleanObjectEmptyArray() throws Exception {
576 final Boolean[] empty = new Boolean[]{};
577 final Boolean[] result = ArrayUtils.nullToEmpty(empty);
578 assertArrayEquals(ArrayUtils.EMPTY_BOOLEAN_OBJECT_ARRAY, result);
579 assertNotSame(empty, result);
580 }
581
582 @Test
583 public void testNullToEmptyBooleanObject() {
584 final Boolean[] original = new Boolean[] {Boolean.TRUE, Boolean.FALSE};
585 assertArrayEquals(original, ArrayUtils.nullToEmpty(original));
586 }
587
588 @Test
589 public void testNullToEmptyLongObjectNull() throws Exception {
590 assertArrayEquals(ArrayUtils.EMPTY_LONG_OBJECT_ARRAY, ArrayUtils.nullToEmpty((Long[]) null));
591 }
592
593 @Test
594 public void testNullToEmptyLongObjectEmptyArray() throws Exception {
595 final Long[] empty = new Long[]{};
596 final Long[] result = ArrayUtils.nullToEmpty(empty);
597 assertArrayEquals(ArrayUtils.EMPTY_LONG_OBJECT_ARRAY, result);
598 assertNotSame(empty, result);
599 }
600
601 @Test
602 public void testNullToEmptyLongObject() {
603 @SuppressWarnings("boxing")
604 final Long[] original = new Long[] {1L, 2L};
605 assertArrayEquals(original, ArrayUtils.nullToEmpty(original));
606 }
607
608 @Test
609 public void testNullToEmptyIntObjectNull() throws Exception {
610 assertArrayEquals(ArrayUtils.EMPTY_INTEGER_OBJECT_ARRAY, ArrayUtils.nullToEmpty((Integer[]) null));
611 }
612
613 @Test
614 public void testNullToEmptyIntObjectEmptyArray() throws Exception {
615 final Integer[] empty = new Integer[]{};
616 final Integer[] result = ArrayUtils.nullToEmpty(empty);
617 assertArrayEquals(ArrayUtils.EMPTY_INTEGER_OBJECT_ARRAY, result);
618 assertNotSame(empty, result);
619 }
620
621 @Test
622 public void testNullToEmptyIntObject() {
623 final Integer[] original = new Integer[] {1, 2};
624 assertArrayEquals(original, ArrayUtils.nullToEmpty(original));
625 }
626
627 @Test
628 public void testNullToEmptyShortObjectNull() throws Exception {
629 assertArrayEquals(ArrayUtils.EMPTY_SHORT_OBJECT_ARRAY, ArrayUtils.nullToEmpty((Short[]) null));
630 }
631
632 @Test
633 public void testNullToEmptyShortObjectEmptyArray() throws Exception {
634 final Short[] empty = new Short[]{};
635 final Short[] result = ArrayUtils.nullToEmpty(empty);
636 assertArrayEquals(ArrayUtils.EMPTY_SHORT_OBJECT_ARRAY, result);
637 assertNotSame(empty, result);
638 }
639
640 @Test
641 public void testNullToEmptyShortObject() {
642 @SuppressWarnings("boxing")
643 final Short[] original = new Short[] {1, 2};
644 assertArrayEquals(original, ArrayUtils.nullToEmpty(original));
645 }
646
647 @Test
648 public void testNUllToEmptyCharObjectNull() throws Exception {
649 assertArrayEquals(ArrayUtils.EMPTY_CHARACTER_OBJECT_ARRAY, ArrayUtils.nullToEmpty((Character[]) null));
650 }
651
652 @Test
653 public void testNullToEmptyCharObjectEmptyArray() throws Exception {
654 final Character[] empty = new Character[]{};
655 final Character[] result = ArrayUtils.nullToEmpty(empty);
656 assertArrayEquals(ArrayUtils.EMPTY_CHARACTER_OBJECT_ARRAY, result);
657 assertNotSame(empty, result);
658 }
659
660 @Test
661 public void testNullToEmptyCharObject() {
662 final Character[] original = new Character[] {'a', 'b'};
663 assertArrayEquals(original, ArrayUtils.nullToEmpty(original));
664 }
665
666 @Test
667 public void testNullToEmptyByteObjectNull() throws Exception {
668 assertArrayEquals(ArrayUtils.EMPTY_BYTE_OBJECT_ARRAY, ArrayUtils.nullToEmpty((Byte[]) null));
669 }
670
671 @Test
672 public void testNullToEmptyByteObjectEmptyArray() throws Exception {
673 final Byte[] empty = new Byte[]{};
674 final Byte[] result = ArrayUtils.nullToEmpty(empty);
675 assertArrayEquals(ArrayUtils.EMPTY_BYTE_OBJECT_ARRAY, result);
676 assertNotSame(empty, result);
677 }
678
679 @Test
680 public void testNullToEmptyByteObject() {
681 final Byte[] original = new Byte[] {0x0F, 0x0E};
682 assertArrayEquals(original, ArrayUtils.nullToEmpty(original));
683 }
684
685 @Test
686 public void testNullToEmptyDoubleObjectNull() throws Exception {
687 assertArrayEquals(ArrayUtils.EMPTY_DOUBLE_OBJECT_ARRAY, ArrayUtils.nullToEmpty((Double[]) null));
688 }
689
690 @Test
691 public void testNullToEmptyDoubleObjectEmptyArray() throws Exception {
692 final Double[] empty = new Double[]{};
693 final Double[] result = ArrayUtils.nullToEmpty(empty);
694 assertArrayEquals(ArrayUtils.EMPTY_DOUBLE_OBJECT_ARRAY, result);
695 assertNotSame(empty, result);
696 }
697
698 @Test
699 public void testNullToEmptyDoubleObject() {
700 final Double[] original = new Double[] {1D, 2D};
701 assertArrayEquals(original, ArrayUtils.nullToEmpty(original));
702 }
703
704 @Test
705 public void testNullToEmptyFloatObjectNull() throws Exception {
706 assertArrayEquals(ArrayUtils.EMPTY_FLOAT_OBJECT_ARRAY, ArrayUtils.nullToEmpty((Float[]) null));
707 }
708
709 @Test
710 public void testNullToEmptyFloatObjectEmptyArray() throws Exception {
711 final Float[] empty = new Float[]{};
712 final Float[] result = ArrayUtils.nullToEmpty(empty);
713 assertArrayEquals(ArrayUtils.EMPTY_FLOAT_OBJECT_ARRAY, result);
714 assertNotSame(empty, result);
715 }
716
717 @Test
718 public void testNullToEmptyFloatObject() {
719 final Float[] original = new Float[] {2.6f, 3.8f};
720 assertArrayEquals(original, ArrayUtils.nullToEmpty(original));
721 }
722
723
724
725 @Test
726 public void testSubarrayObject() {
727 final Object[] nullArray = null;
728 final Object[] objectArray = { "a", "b", "c", "d", "e", "f"};
729
730 assertEquals("0 start, mid end", "abcd",
731 StringUtils.join(ArrayUtils.subarray(objectArray, 0, 4)));
732 assertEquals("0 start, length end", "abcdef",
733 StringUtils.join(ArrayUtils.subarray(objectArray, 0, objectArray.length)));
734 assertEquals("mid start, mid end", "bcd",
735 StringUtils.join(ArrayUtils.subarray(objectArray, 1, 4)));
736 assertEquals("mid start, length end", "bcdef",
737 StringUtils.join(ArrayUtils.subarray(objectArray, 1, objectArray.length)));
738
739 assertNull("null input", ArrayUtils.subarray(nullArray, 0, 3));
740 assertEquals("empty array", "",
741 StringUtils.join(ArrayUtils.subarray(ArrayUtils.EMPTY_OBJECT_ARRAY, 1, 2)));
742 assertEquals("start > end", "",
743 StringUtils.join(ArrayUtils.subarray(objectArray, 4, 2)));
744 assertEquals("start == end", "",
745 StringUtils.join(ArrayUtils.subarray(objectArray, 3, 3)));
746 assertEquals("start undershoot, normal end", "abcd",
747 StringUtils.join(ArrayUtils.subarray(objectArray, -2, 4)));
748 assertEquals("start overshoot, any end", "",
749 StringUtils.join(ArrayUtils.subarray(objectArray, 33, 4)));
750 assertEquals("normal start, end overshoot", "cdef",
751 StringUtils.join(ArrayUtils.subarray(objectArray, 2, 33)));
752 assertEquals("start undershoot, end overshoot", "abcdef",
753 StringUtils.join(ArrayUtils.subarray(objectArray, -2, 12)));
754
755
756 final Date[] dateArray = { new java.sql.Date(new Date().getTime()),
757 new Date(), new Date(), new Date(), new Date() };
758
759 assertSame("Object type", Object.class,
760 ArrayUtils.subarray(objectArray, 2, 4).getClass().getComponentType());
761 assertSame("java.util.Date type", java.util.Date.class,
762 ArrayUtils.subarray(dateArray, 1, 4).getClass().getComponentType());
763 assertNotSame("java.sql.Date type", java.sql.Date.class,
764 ArrayUtils.subarray(dateArray, 1, 4).getClass().getComponentType());
765 try {
766 @SuppressWarnings("unused")
767 final
768 java.sql.Date[] dummy = (java.sql.Date[])ArrayUtils.subarray(dateArray, 1,3);
769 fail("Invalid downcast");
770 } catch (final ClassCastException e) {}
771 }
772
773 @Test
774 public void testSubarrayLong() {
775 final long[] nullArray = null;
776 final long[] array = { 999910, 999911, 999912, 999913, 999914, 999915 };
777 final long[] leftSubarray = { 999910, 999911, 999912, 999913 };
778 final long[] midSubarray = { 999911, 999912, 999913, 999914 };
779 final long[] rightSubarray = { 999912, 999913, 999914, 999915 };
780
781 assertTrue("0 start, mid end",
782 ArrayUtils.isEquals(leftSubarray,
783 ArrayUtils.subarray(array, 0, 4)));
784
785 assertTrue("0 start, length end",
786 ArrayUtils.isEquals(array,
787 ArrayUtils.subarray(array, 0, array.length)));
788
789 assertTrue("mid start, mid end",
790 ArrayUtils.isEquals(midSubarray,
791 ArrayUtils.subarray(array, 1, 5)));
792
793 assertTrue("mid start, length end",
794 ArrayUtils.isEquals(rightSubarray,
795 ArrayUtils.subarray(array, 2, array.length)));
796
797
798 assertNull("null input", ArrayUtils.subarray(nullArray, 0, 3));
799
800 assertEquals("empty array", ArrayUtils.EMPTY_LONG_ARRAY,
801 ArrayUtils.subarray(ArrayUtils.EMPTY_LONG_ARRAY, 1, 2));
802
803 assertEquals("start > end", ArrayUtils.EMPTY_LONG_ARRAY,
804 ArrayUtils.subarray(array, 4, 2));
805
806 assertEquals("start == end", ArrayUtils.EMPTY_LONG_ARRAY,
807 ArrayUtils.subarray(array, 3, 3));
808
809 assertTrue("start undershoot, normal end",
810 ArrayUtils.isEquals(leftSubarray,
811 ArrayUtils.subarray(array, -2, 4)));
812
813 assertEquals("start overshoot, any end",
814 ArrayUtils.EMPTY_LONG_ARRAY,
815 ArrayUtils.subarray(array, 33, 4));
816
817 assertTrue("normal start, end overshoot",
818 ArrayUtils.isEquals(rightSubarray,
819 ArrayUtils.subarray(array, 2, 33)));
820
821 assertTrue("start undershoot, end overshoot",
822 ArrayUtils.isEquals(array,
823 ArrayUtils.subarray(array, -2, 12)));
824
825
826
827 assertSame("empty array, object test",
828 ArrayUtils.EMPTY_LONG_ARRAY,
829 ArrayUtils.subarray(ArrayUtils.EMPTY_LONG_ARRAY, 1, 2));
830
831 assertSame("start > end, object test",
832 ArrayUtils.EMPTY_LONG_ARRAY,
833 ArrayUtils.subarray(array, 4, 1));
834
835 assertSame("start == end, object test",
836 ArrayUtils.EMPTY_LONG_ARRAY,
837 ArrayUtils.subarray(array, 3, 3));
838
839 assertSame("start overshoot, any end, object test",
840 ArrayUtils.EMPTY_LONG_ARRAY,
841 ArrayUtils.subarray(array, 8733, 4));
842
843
844
845 assertSame("long type", long.class,
846 ArrayUtils.subarray(array, 2, 4).getClass().getComponentType());
847
848 }
849
850 @Test
851 public void testSubarrayInt() {
852 final int[] nullArray = null;
853 final int[] array = { 10, 11, 12, 13, 14, 15 };
854 final int[] leftSubarray = { 10, 11, 12, 13 };
855 final int[] midSubarray = { 11, 12, 13, 14 };
856 final int[] rightSubarray = { 12, 13, 14, 15 };
857
858
859 assertTrue("0 start, mid end",
860 ArrayUtils.isEquals(leftSubarray,
861 ArrayUtils.subarray(array, 0, 4)));
862
863 assertTrue("0 start, length end",
864 ArrayUtils.isEquals(array,
865 ArrayUtils.subarray(array, 0, array.length)));
866
867 assertTrue("mid start, mid end",
868 ArrayUtils.isEquals(midSubarray,
869 ArrayUtils.subarray(array, 1, 5)));
870
871 assertTrue("mid start, length end",
872 ArrayUtils.isEquals(rightSubarray,
873 ArrayUtils.subarray(array, 2, array.length)));
874
875
876 assertNull("null input", ArrayUtils.subarray(nullArray, 0, 3));
877
878 assertEquals("empty array", ArrayUtils.EMPTY_INT_ARRAY,
879 ArrayUtils.subarray(ArrayUtils.EMPTY_INT_ARRAY, 1, 2));
880
881 assertEquals("start > end", ArrayUtils.EMPTY_INT_ARRAY,
882 ArrayUtils.subarray(array, 4, 2));
883
884 assertEquals("start == end", ArrayUtils.EMPTY_INT_ARRAY,
885 ArrayUtils.subarray(array, 3, 3));
886
887 assertTrue("start undershoot, normal end",
888 ArrayUtils.isEquals(leftSubarray,
889 ArrayUtils.subarray(array, -2, 4)));
890
891 assertEquals("start overshoot, any end",
892 ArrayUtils.EMPTY_INT_ARRAY,
893 ArrayUtils.subarray(array, 33, 4));
894
895 assertTrue("normal start, end overshoot",
896 ArrayUtils.isEquals(rightSubarray,
897 ArrayUtils.subarray(array, 2, 33)));
898
899 assertTrue("start undershoot, end overshoot",
900 ArrayUtils.isEquals(array,
901 ArrayUtils.subarray(array, -2, 12)));
902
903
904
905 assertSame("empty array, object test",
906 ArrayUtils.EMPTY_INT_ARRAY,
907 ArrayUtils.subarray(ArrayUtils.EMPTY_INT_ARRAY, 1, 2));
908
909 assertSame("start > end, object test",
910 ArrayUtils.EMPTY_INT_ARRAY,
911 ArrayUtils.subarray(array, 4, 1));
912
913 assertSame("start == end, object test",
914 ArrayUtils.EMPTY_INT_ARRAY,
915 ArrayUtils.subarray(array, 3, 3));
916
917 assertSame("start overshoot, any end, object test",
918 ArrayUtils.EMPTY_INT_ARRAY,
919 ArrayUtils.subarray(array, 8733, 4));
920
921
922
923 assertSame("int type", int.class,
924 ArrayUtils.subarray(array, 2, 4).getClass().getComponentType());
925
926 }
927
928 @Test
929 public void testSubarrayShort() {
930 final short[] nullArray = null;
931 final short[] array = { 10, 11, 12, 13, 14, 15 };
932 final short[] leftSubarray = { 10, 11, 12, 13 };
933 final short[] midSubarray = { 11, 12, 13, 14 };
934 final short[] rightSubarray = { 12, 13, 14, 15 };
935
936
937 assertTrue("0 start, mid end",
938 ArrayUtils.isEquals(leftSubarray,
939 ArrayUtils.subarray(array, 0, 4)));
940
941 assertTrue("0 start, length end",
942 ArrayUtils.isEquals(array,
943 ArrayUtils.subarray(array, 0, array.length)));
944
945 assertTrue("mid start, mid end",
946 ArrayUtils.isEquals(midSubarray,
947 ArrayUtils.subarray(array, 1, 5)));
948
949 assertTrue("mid start, length end",
950 ArrayUtils.isEquals(rightSubarray,
951 ArrayUtils.subarray(array, 2, array.length)));
952
953
954 assertNull("null input", ArrayUtils.subarray(nullArray, 0, 3));
955
956 assertEquals("empty array", ArrayUtils.EMPTY_SHORT_ARRAY,
957 ArrayUtils.subarray(ArrayUtils.EMPTY_SHORT_ARRAY, 1, 2));
958
959 assertEquals("start > end", ArrayUtils.EMPTY_SHORT_ARRAY,
960 ArrayUtils.subarray(array, 4, 2));
961
962 assertEquals("start == end", ArrayUtils.EMPTY_SHORT_ARRAY,
963 ArrayUtils.subarray(array, 3, 3));
964
965 assertTrue("start undershoot, normal end",
966 ArrayUtils.isEquals(leftSubarray,
967 ArrayUtils.subarray(array, -2, 4)));
968
969 assertEquals("start overshoot, any end",
970 ArrayUtils.EMPTY_SHORT_ARRAY,
971 ArrayUtils.subarray(array, 33, 4));
972
973 assertTrue("normal start, end overshoot",
974 ArrayUtils.isEquals(rightSubarray,
975 ArrayUtils.subarray(array, 2, 33)));
976
977 assertTrue("start undershoot, end overshoot",
978 ArrayUtils.isEquals(array,
979 ArrayUtils.subarray(array, -2, 12)));
980
981
982
983 assertSame("empty array, object test",
984 ArrayUtils.EMPTY_SHORT_ARRAY,
985 ArrayUtils.subarray(ArrayUtils.EMPTY_SHORT_ARRAY, 1, 2));
986
987 assertSame("start > end, object test",
988 ArrayUtils.EMPTY_SHORT_ARRAY,
989 ArrayUtils.subarray(array, 4, 1));
990
991 assertSame("start == end, object test",
992 ArrayUtils.EMPTY_SHORT_ARRAY,
993 ArrayUtils.subarray(array, 3, 3));
994
995 assertSame("start overshoot, any end, object test",
996 ArrayUtils.EMPTY_SHORT_ARRAY,
997 ArrayUtils.subarray(array, 8733, 4));
998
999
1000
1001 assertSame("short type", short.class,
1002 ArrayUtils.subarray(array, 2, 4).getClass().getComponentType());
1003
1004 }
1005
1006 @Test
1007 public void testSubarrChar() {
1008 final char[] nullArray = null;
1009 final char[] array = { 'a', 'b', 'c', 'd', 'e', 'f' };
1010 final char[] leftSubarray = { 'a', 'b', 'c', 'd', };
1011 final char[] midSubarray = { 'b', 'c', 'd', 'e', };
1012 final char[] rightSubarray = { 'c', 'd', 'e', 'f', };
1013
1014
1015 assertTrue("0 start, mid end",
1016 ArrayUtils.isEquals(leftSubarray,
1017 ArrayUtils.subarray(array, 0, 4)));
1018
1019 assertTrue("0 start, length end",
1020 ArrayUtils.isEquals(array,
1021 ArrayUtils.subarray(array, 0, array.length)));
1022
1023 assertTrue("mid start, mid end",
1024 ArrayUtils.isEquals(midSubarray,
1025 ArrayUtils.subarray(array, 1, 5)));
1026
1027 assertTrue("mid start, length end",
1028 ArrayUtils.isEquals(rightSubarray,
1029 ArrayUtils.subarray(array, 2, array.length)));
1030
1031
1032 assertNull("null input", ArrayUtils.subarray(nullArray, 0, 3));
1033
1034 assertEquals("empty array", ArrayUtils.EMPTY_CHAR_ARRAY,
1035 ArrayUtils.subarray(ArrayUtils.EMPTY_CHAR_ARRAY, 1, 2));
1036
1037 assertEquals("start > end", ArrayUtils.EMPTY_CHAR_ARRAY,
1038 ArrayUtils.subarray(array, 4, 2));
1039
1040 assertEquals("start == end", ArrayUtils.EMPTY_CHAR_ARRAY,
1041 ArrayUtils.subarray(array, 3, 3));
1042
1043 assertTrue("start undershoot, normal end",
1044 ArrayUtils.isEquals(leftSubarray,
1045 ArrayUtils.subarray(array, -2, 4)));
1046
1047 assertEquals("start overshoot, any end",
1048 ArrayUtils.EMPTY_CHAR_ARRAY,
1049 ArrayUtils.subarray(array, 33, 4));
1050
1051 assertTrue("normal start, end overshoot",
1052 ArrayUtils.isEquals(rightSubarray,
1053 ArrayUtils.subarray(array, 2, 33)));
1054
1055 assertTrue("start undershoot, end overshoot",
1056 ArrayUtils.isEquals(array,
1057 ArrayUtils.subarray(array, -2, 12)));
1058
1059
1060
1061 assertSame("empty array, object test",
1062 ArrayUtils.EMPTY_CHAR_ARRAY,
1063 ArrayUtils.subarray(ArrayUtils.EMPTY_CHAR_ARRAY, 1, 2));
1064
1065 assertSame("start > end, object test",
1066 ArrayUtils.EMPTY_CHAR_ARRAY,
1067 ArrayUtils.subarray(array, 4, 1));
1068
1069 assertSame("start == end, object test",
1070 ArrayUtils.EMPTY_CHAR_ARRAY,
1071 ArrayUtils.subarray(array, 3, 3));
1072
1073 assertSame("start overshoot, any end, object test",
1074 ArrayUtils.EMPTY_CHAR_ARRAY,
1075 ArrayUtils.subarray(array, 8733, 4));
1076
1077
1078
1079 assertSame("char type", char.class,
1080 ArrayUtils.subarray(array, 2, 4).getClass().getComponentType());
1081
1082 }
1083
1084 @Test
1085 public void testSubarrayByte() {
1086 final byte[] nullArray = null;
1087 final byte[] array = { 10, 11, 12, 13, 14, 15 };
1088 final byte[] leftSubarray = { 10, 11, 12, 13 };
1089 final byte[] midSubarray = { 11, 12, 13, 14 };
1090 final byte[] rightSubarray = { 12, 13, 14, 15 };
1091
1092
1093 assertTrue("0 start, mid end",
1094 ArrayUtils.isEquals(leftSubarray,
1095 ArrayUtils.subarray(array, 0, 4)));
1096
1097 assertTrue("0 start, length end",
1098 ArrayUtils.isEquals(array,
1099 ArrayUtils.subarray(array, 0, array.length)));
1100
1101 assertTrue("mid start, mid end",
1102 ArrayUtils.isEquals(midSubarray,
1103 ArrayUtils.subarray(array, 1, 5)));
1104
1105 assertTrue("mid start, length end",
1106 ArrayUtils.isEquals(rightSubarray,
1107 ArrayUtils.subarray(array, 2, array.length)));
1108
1109
1110 assertNull("null input", ArrayUtils.subarray(nullArray, 0, 3));
1111
1112 assertEquals("empty array", ArrayUtils.EMPTY_BYTE_ARRAY,
1113 ArrayUtils.subarray(ArrayUtils.EMPTY_BYTE_ARRAY, 1, 2));
1114
1115 assertEquals("start > end", ArrayUtils.EMPTY_BYTE_ARRAY,
1116 ArrayUtils.subarray(array, 4, 2));
1117
1118 assertEquals("start == end", ArrayUtils.EMPTY_BYTE_ARRAY,
1119 ArrayUtils.subarray(array, 3, 3));
1120
1121 assertTrue("start undershoot, normal end",
1122 ArrayUtils.isEquals(leftSubarray,
1123 ArrayUtils.subarray(array, -2, 4)));
1124
1125 assertEquals("start overshoot, any end",
1126 ArrayUtils.EMPTY_BYTE_ARRAY,
1127 ArrayUtils.subarray(array, 33, 4));
1128
1129 assertTrue("normal start, end overshoot",
1130 ArrayUtils.isEquals(rightSubarray,
1131 ArrayUtils.subarray(array, 2, 33)));
1132
1133 assertTrue("start undershoot, end overshoot",
1134 ArrayUtils.isEquals(array,
1135 ArrayUtils.subarray(array, -2, 12)));
1136
1137
1138
1139 assertSame("empty array, object test",
1140 ArrayUtils.EMPTY_BYTE_ARRAY,
1141 ArrayUtils.subarray(ArrayUtils.EMPTY_BYTE_ARRAY, 1, 2));
1142
1143 assertSame("start > end, object test",
1144 ArrayUtils.EMPTY_BYTE_ARRAY,
1145 ArrayUtils.subarray(array, 4, 1));
1146
1147 assertSame("start == end, object test",
1148 ArrayUtils.EMPTY_BYTE_ARRAY,
1149 ArrayUtils.subarray(array, 3, 3));
1150
1151 assertSame("start overshoot, any end, object test",
1152 ArrayUtils.EMPTY_BYTE_ARRAY,
1153 ArrayUtils.subarray(array, 8733, 4));
1154
1155
1156
1157 assertSame("byte type", byte.class,
1158 ArrayUtils.subarray(array, 2, 4).getClass().getComponentType());
1159
1160 }
1161
1162 @Test
1163 public void testSubarrayDouble() {
1164 final double[] nullArray = null;
1165 final double[] array = { 10.123, 11.234, 12.345, 13.456, 14.567, 15.678 };
1166 final double[] leftSubarray = { 10.123, 11.234, 12.345, 13.456, };
1167 final double[] midSubarray = { 11.234, 12.345, 13.456, 14.567, };
1168 final double[] rightSubarray = { 12.345, 13.456, 14.567, 15.678 };
1169
1170
1171 assertTrue("0 start, mid end",
1172 ArrayUtils.isEquals(leftSubarray,
1173 ArrayUtils.subarray(array, 0, 4)));
1174
1175 assertTrue("0 start, length end",
1176 ArrayUtils.isEquals(array,
1177 ArrayUtils.subarray(array, 0, array.length)));
1178
1179 assertTrue("mid start, mid end",
1180 ArrayUtils.isEquals(midSubarray,
1181 ArrayUtils.subarray(array, 1, 5)));
1182
1183 assertTrue("mid start, length end",
1184 ArrayUtils.isEquals(rightSubarray,
1185 ArrayUtils.subarray(array, 2, array.length)));
1186
1187
1188 assertNull("null input", ArrayUtils.subarray(nullArray, 0, 3));
1189
1190 assertEquals("empty array", ArrayUtils.EMPTY_DOUBLE_ARRAY,
1191 ArrayUtils.subarray(ArrayUtils.EMPTY_DOUBLE_ARRAY, 1, 2));
1192
1193 assertEquals("start > end", ArrayUtils.EMPTY_DOUBLE_ARRAY,
1194 ArrayUtils.subarray(array, 4, 2));
1195
1196 assertEquals("start == end", ArrayUtils.EMPTY_DOUBLE_ARRAY,
1197 ArrayUtils.subarray(array, 3, 3));
1198
1199 assertTrue("start undershoot, normal end",
1200 ArrayUtils.isEquals(leftSubarray,
1201 ArrayUtils.subarray(array, -2, 4)));
1202
1203 assertEquals("start overshoot, any end",
1204 ArrayUtils.EMPTY_DOUBLE_ARRAY,
1205 ArrayUtils.subarray(array, 33, 4));
1206
1207 assertTrue("normal start, end overshoot",
1208 ArrayUtils.isEquals(rightSubarray,
1209 ArrayUtils.subarray(array, 2, 33)));
1210
1211 assertTrue("start undershoot, end overshoot",
1212 ArrayUtils.isEquals(array,
1213 ArrayUtils.subarray(array, -2, 12)));
1214
1215
1216
1217 assertSame("empty array, object test",
1218 ArrayUtils.EMPTY_DOUBLE_ARRAY,
1219 ArrayUtils.subarray(ArrayUtils.EMPTY_DOUBLE_ARRAY, 1, 2));
1220
1221 assertSame("start > end, object test",
1222 ArrayUtils.EMPTY_DOUBLE_ARRAY,
1223 ArrayUtils.subarray(array, 4, 1));
1224
1225 assertSame("start == end, object test",
1226 ArrayUtils.EMPTY_DOUBLE_ARRAY,
1227 ArrayUtils.subarray(array, 3, 3));
1228
1229 assertSame("start overshoot, any end, object test",
1230 ArrayUtils.EMPTY_DOUBLE_ARRAY,
1231 ArrayUtils.subarray(array, 8733, 4));
1232
1233
1234
1235 assertSame("double type", double.class,
1236 ArrayUtils.subarray(array, 2, 4).getClass().getComponentType());
1237
1238 }
1239
1240 @Test
1241 public void testSubarrayFloat() {
1242 final float[] nullArray = null;
1243 final float[] array = { 10, 11, 12, 13, 14, 15 };
1244 final float[] leftSubarray = { 10, 11, 12, 13 };
1245 final float[] midSubarray = { 11, 12, 13, 14 };
1246 final float[] rightSubarray = { 12, 13, 14, 15 };
1247
1248
1249 assertTrue("0 start, mid end",
1250 ArrayUtils.isEquals(leftSubarray,
1251 ArrayUtils.subarray(array, 0, 4)));
1252
1253 assertTrue("0 start, length end",
1254 ArrayUtils.isEquals(array,
1255 ArrayUtils.subarray(array, 0, array.length)));
1256
1257 assertTrue("mid start, mid end",
1258 ArrayUtils.isEquals(midSubarray,
1259 ArrayUtils.subarray(array, 1, 5)));
1260
1261 assertTrue("mid start, length end",
1262 ArrayUtils.isEquals(rightSubarray,
1263 ArrayUtils.subarray(array, 2, array.length)));
1264
1265
1266 assertNull("null input", ArrayUtils.subarray(nullArray, 0, 3));
1267
1268 assertEquals("empty array", ArrayUtils.EMPTY_FLOAT_ARRAY,
1269 ArrayUtils.subarray(ArrayUtils.EMPTY_FLOAT_ARRAY, 1, 2));
1270
1271 assertEquals("start > end", ArrayUtils.EMPTY_FLOAT_ARRAY,
1272 ArrayUtils.subarray(array, 4, 2));
1273
1274 assertEquals("start == end", ArrayUtils.EMPTY_FLOAT_ARRAY,
1275 ArrayUtils.subarray(array, 3, 3));
1276
1277 assertTrue("start undershoot, normal end",
1278 ArrayUtils.isEquals(leftSubarray,
1279 ArrayUtils.subarray(array, -2, 4)));
1280
1281 assertEquals("start overshoot, any end",
1282 ArrayUtils.EMPTY_FLOAT_ARRAY,
1283 ArrayUtils.subarray(array, 33, 4));
1284
1285 assertTrue("normal start, end overshoot",
1286 ArrayUtils.isEquals(rightSubarray,
1287 ArrayUtils.subarray(array, 2, 33)));
1288
1289 assertTrue("start undershoot, end overshoot",
1290 ArrayUtils.isEquals(array,
1291 ArrayUtils.subarray(array, -2, 12)));
1292
1293
1294
1295 assertSame("empty array, object test",
1296 ArrayUtils.EMPTY_FLOAT_ARRAY,
1297 ArrayUtils.subarray(ArrayUtils.EMPTY_FLOAT_ARRAY, 1, 2));
1298
1299 assertSame("start > end, object test",
1300 ArrayUtils.EMPTY_FLOAT_ARRAY,
1301 ArrayUtils.subarray(array, 4, 1));
1302
1303 assertSame("start == end, object test",
1304 ArrayUtils.EMPTY_FLOAT_ARRAY,
1305 ArrayUtils.subarray(array, 3, 3));
1306
1307 assertSame("start overshoot, any end, object test",
1308 ArrayUtils.EMPTY_FLOAT_ARRAY,
1309 ArrayUtils.subarray(array, 8733, 4));
1310
1311
1312
1313 assertSame("float type", float.class,
1314 ArrayUtils.subarray(array, 2, 4).getClass().getComponentType());
1315
1316 }
1317
1318 @Test
1319 public void testSubarrayBoolean() {
1320 final boolean[] nullArray = null;
1321 final boolean[] array = { true, true, false, true, false, true };
1322 final boolean[] leftSubarray = { true, true, false, true };
1323 final boolean[] midSubarray = { true, false, true, false };
1324 final boolean[] rightSubarray = { false, true, false, true };
1325
1326
1327 assertTrue("0 start, mid end",
1328 ArrayUtils.isEquals(leftSubarray,
1329 ArrayUtils.subarray(array, 0, 4)));
1330
1331 assertTrue("0 start, length end",
1332 ArrayUtils.isEquals(array,
1333 ArrayUtils.subarray(array, 0, array.length)));
1334
1335 assertTrue("mid start, mid end",
1336 ArrayUtils.isEquals(midSubarray,
1337 ArrayUtils.subarray(array, 1, 5)));
1338
1339 assertTrue("mid start, length end",
1340 ArrayUtils.isEquals(rightSubarray,
1341 ArrayUtils.subarray(array, 2, array.length)));
1342
1343
1344 assertNull("null input", ArrayUtils.subarray(nullArray, 0, 3));
1345
1346 assertEquals("empty array", ArrayUtils.EMPTY_BOOLEAN_ARRAY,
1347 ArrayUtils.subarray(ArrayUtils.EMPTY_BOOLEAN_ARRAY, 1, 2));
1348
1349 assertEquals("start > end", ArrayUtils.EMPTY_BOOLEAN_ARRAY,
1350 ArrayUtils.subarray(array, 4, 2));
1351
1352 assertEquals("start == end", ArrayUtils.EMPTY_BOOLEAN_ARRAY,
1353 ArrayUtils.subarray(array, 3, 3));
1354
1355 assertTrue("start undershoot, normal end",
1356 ArrayUtils.isEquals(leftSubarray,
1357 ArrayUtils.subarray(array, -2, 4)));
1358
1359 assertEquals("start overshoot, any end",
1360 ArrayUtils.EMPTY_BOOLEAN_ARRAY,
1361 ArrayUtils.subarray(array, 33, 4));
1362
1363 assertTrue("normal start, end overshoot",
1364 ArrayUtils.isEquals(rightSubarray,
1365 ArrayUtils.subarray(array, 2, 33)));
1366
1367 assertTrue("start undershoot, end overshoot",
1368 ArrayUtils.isEquals(array,
1369 ArrayUtils.subarray(array, -2, 12)));
1370
1371
1372
1373 assertSame("empty array, object test",
1374 ArrayUtils.EMPTY_BOOLEAN_ARRAY,
1375 ArrayUtils.subarray(ArrayUtils.EMPTY_BOOLEAN_ARRAY, 1, 2));
1376
1377 assertSame("start > end, object test",
1378 ArrayUtils.EMPTY_BOOLEAN_ARRAY,
1379 ArrayUtils.subarray(array, 4, 1));
1380
1381 assertSame("start == end, object test",
1382 ArrayUtils.EMPTY_BOOLEAN_ARRAY,
1383 ArrayUtils.subarray(array, 3, 3));
1384
1385 assertSame("start overshoot, any end, object test",
1386 ArrayUtils.EMPTY_BOOLEAN_ARRAY,
1387 ArrayUtils.subarray(array, 8733, 4));
1388
1389
1390
1391 assertSame("boolean type", boolean.class,
1392 ArrayUtils.subarray(array, 2, 4).getClass().getComponentType());
1393
1394 }
1395
1396
1397 @Test
1398 public void testSameLength() {
1399 final Object[] nullArray = null;
1400 final Object[] emptyArray = new Object[0];
1401 final Object[] oneArray = new Object[] {"pick"};
1402 final Object[] twoArray = new Object[] {"pick", "stick"};
1403
1404 assertTrue(ArrayUtils.isSameLength(nullArray, nullArray));
1405 assertTrue(ArrayUtils.isSameLength(nullArray, emptyArray));
1406 assertFalse(ArrayUtils.isSameLength(nullArray, oneArray));
1407 assertFalse(ArrayUtils.isSameLength(nullArray, twoArray));
1408
1409 assertTrue(ArrayUtils.isSameLength(emptyArray, nullArray));
1410 assertTrue(ArrayUtils.isSameLength(emptyArray, emptyArray));
1411 assertFalse(ArrayUtils.isSameLength(emptyArray, oneArray));
1412 assertFalse(ArrayUtils.isSameLength(emptyArray, twoArray));
1413
1414 assertFalse(ArrayUtils.isSameLength(oneArray, nullArray));
1415 assertFalse(ArrayUtils.isSameLength(oneArray, emptyArray));
1416 assertTrue(ArrayUtils.isSameLength(oneArray, oneArray));
1417 assertFalse(ArrayUtils.isSameLength(oneArray, twoArray));
1418
1419 assertFalse(ArrayUtils.isSameLength(twoArray, nullArray));
1420 assertFalse(ArrayUtils.isSameLength(twoArray, emptyArray));
1421 assertFalse(ArrayUtils.isSameLength(twoArray, oneArray));
1422 assertTrue(ArrayUtils.isSameLength(twoArray, twoArray));
1423 }
1424
1425 @Test
1426 public void testSameLengthBoolean() {
1427 final boolean[] nullArray = null;
1428 final boolean[] emptyArray = new boolean[0];
1429 final boolean[] oneArray = new boolean[] {true};
1430 final boolean[] twoArray = new boolean[] {true, false};
1431
1432 assertTrue(ArrayUtils.isSameLength(nullArray, nullArray));
1433 assertTrue(ArrayUtils.isSameLength(nullArray, emptyArray));
1434 assertFalse(ArrayUtils.isSameLength(nullArray, oneArray));
1435 assertFalse(ArrayUtils.isSameLength(nullArray, twoArray));
1436
1437 assertTrue(ArrayUtils.isSameLength(emptyArray, nullArray));
1438 assertTrue(ArrayUtils.isSameLength(emptyArray, emptyArray));
1439 assertFalse(ArrayUtils.isSameLength(emptyArray, oneArray));
1440 assertFalse(ArrayUtils.isSameLength(emptyArray, twoArray));
1441
1442 assertFalse(ArrayUtils.isSameLength(oneArray, nullArray));
1443 assertFalse(ArrayUtils.isSameLength(oneArray, emptyArray));
1444 assertTrue(ArrayUtils.isSameLength(oneArray, oneArray));
1445 assertFalse(ArrayUtils.isSameLength(oneArray, twoArray));
1446
1447 assertFalse(ArrayUtils.isSameLength(twoArray, nullArray));
1448 assertFalse(ArrayUtils.isSameLength(twoArray, emptyArray));
1449 assertFalse(ArrayUtils.isSameLength(twoArray, oneArray));
1450 assertTrue(ArrayUtils.isSameLength(twoArray, twoArray));
1451 }
1452
1453 @Test
1454 public void testSameLengthLong() {
1455 final long[] nullArray = null;
1456 final long[] emptyArray = new long[0];
1457 final long[] oneArray = new long[] {0L};
1458 final long[] twoArray = new long[] {0L, 76L};
1459
1460 assertTrue(ArrayUtils.isSameLength(nullArray, nullArray));
1461 assertTrue(ArrayUtils.isSameLength(nullArray, emptyArray));
1462 assertFalse(ArrayUtils.isSameLength(nullArray, oneArray));
1463 assertFalse(ArrayUtils.isSameLength(nullArray, twoArray));
1464
1465 assertTrue(ArrayUtils.isSameLength(emptyArray, nullArray));
1466 assertTrue(ArrayUtils.isSameLength(emptyArray, emptyArray));
1467 assertFalse(ArrayUtils.isSameLength(emptyArray, oneArray));
1468 assertFalse(ArrayUtils.isSameLength(emptyArray, twoArray));
1469
1470 assertFalse(ArrayUtils.isSameLength(oneArray, nullArray));
1471 assertFalse(ArrayUtils.isSameLength(oneArray, emptyArray));
1472 assertTrue(ArrayUtils.isSameLength(oneArray, oneArray));
1473 assertFalse(ArrayUtils.isSameLength(oneArray, twoArray));
1474
1475 assertFalse(ArrayUtils.isSameLength(twoArray, nullArray));
1476 assertFalse(ArrayUtils.isSameLength(twoArray, emptyArray));
1477 assertFalse(ArrayUtils.isSameLength(twoArray, oneArray));
1478 assertTrue(ArrayUtils.isSameLength(twoArray, twoArray));
1479 }
1480
1481 @Test
1482 public void testSameLengthInt() {
1483 final int[] nullArray = null;
1484 final int[] emptyArray = new int[0];
1485 final int[] oneArray = new int[] {4};
1486 final int[] twoArray = new int[] {5, 7};
1487
1488 assertTrue(ArrayUtils.isSameLength(nullArray, nullArray));
1489 assertTrue(ArrayUtils.isSameLength(nullArray, emptyArray));
1490 assertFalse(ArrayUtils.isSameLength(nullArray, oneArray));
1491 assertFalse(ArrayUtils.isSameLength(nullArray, twoArray));
1492
1493 assertTrue(ArrayUtils.isSameLength(emptyArray, nullArray));
1494 assertTrue(ArrayUtils.isSameLength(emptyArray, emptyArray));
1495 assertFalse(ArrayUtils.isSameLength(emptyArray, oneArray));
1496 assertFalse(ArrayUtils.isSameLength(emptyArray, twoArray));
1497
1498 assertFalse(ArrayUtils.isSameLength(oneArray, nullArray));
1499 assertFalse(ArrayUtils.isSameLength(oneArray, emptyArray));
1500 assertTrue(ArrayUtils.isSameLength(oneArray, oneArray));
1501 assertFalse(ArrayUtils.isSameLength(oneArray, twoArray));
1502
1503 assertFalse(ArrayUtils.isSameLength(twoArray, nullArray));
1504 assertFalse(ArrayUtils.isSameLength(twoArray, emptyArray));
1505 assertFalse(ArrayUtils.isSameLength(twoArray, oneArray));
1506 assertTrue(ArrayUtils.isSameLength(twoArray, twoArray));
1507 }
1508
1509 @Test
1510 public void testSameLengthShort() {
1511 final short[] nullArray = null;
1512 final short[] emptyArray = new short[0];
1513 final short[] oneArray = new short[] {4};
1514 final short[] twoArray = new short[] {6, 8};
1515
1516 assertTrue(ArrayUtils.isSameLength(nullArray, nullArray));
1517 assertTrue(ArrayUtils.isSameLength(nullArray, emptyArray));
1518 assertFalse(ArrayUtils.isSameLength(nullArray, oneArray));
1519 assertFalse(ArrayUtils.isSameLength(nullArray, twoArray));
1520
1521 assertTrue(ArrayUtils.isSameLength(emptyArray, nullArray));
1522 assertTrue(ArrayUtils.isSameLength(emptyArray, emptyArray));
1523 assertFalse(ArrayUtils.isSameLength(emptyArray, oneArray));
1524 assertFalse(ArrayUtils.isSameLength(emptyArray, twoArray));
1525
1526 assertFalse(ArrayUtils.isSameLength(oneArray, nullArray));
1527 assertFalse(ArrayUtils.isSameLength(oneArray, emptyArray));
1528 assertTrue(ArrayUtils.isSameLength(oneArray, oneArray));
1529 assertFalse(ArrayUtils.isSameLength(oneArray, twoArray));
1530
1531 assertFalse(ArrayUtils.isSameLength(twoArray, nullArray));
1532 assertFalse(ArrayUtils.isSameLength(twoArray, emptyArray));
1533 assertFalse(ArrayUtils.isSameLength(twoArray, oneArray));
1534 assertTrue(ArrayUtils.isSameLength(twoArray, twoArray));
1535 }
1536
1537 @Test
1538 public void testSameLengthChar() {
1539 final char[] nullArray = null;
1540 final char[] emptyArray = new char[0];
1541 final char[] oneArray = new char[] {'f'};
1542 final char[] twoArray = new char[] {'d', 't'};
1543
1544 assertTrue(ArrayUtils.isSameLength(nullArray, nullArray));
1545 assertTrue(ArrayUtils.isSameLength(nullArray, emptyArray));
1546 assertFalse(ArrayUtils.isSameLength(nullArray, oneArray));
1547 assertFalse(ArrayUtils.isSameLength(nullArray, twoArray));
1548
1549 assertTrue(ArrayUtils.isSameLength(emptyArray, nullArray));
1550 assertTrue(ArrayUtils.isSameLength(emptyArray, emptyArray));
1551 assertFalse(ArrayUtils.isSameLength(emptyArray, oneArray));
1552 assertFalse(ArrayUtils.isSameLength(emptyArray, twoArray));
1553
1554 assertFalse(ArrayUtils.isSameLength(oneArray, nullArray));
1555 assertFalse(ArrayUtils.isSameLength(oneArray, emptyArray));
1556 assertTrue(ArrayUtils.isSameLength(oneArray, oneArray));
1557 assertFalse(ArrayUtils.isSameLength(oneArray, twoArray));
1558
1559 assertFalse(ArrayUtils.isSameLength(twoArray, nullArray));
1560 assertFalse(ArrayUtils.isSameLength(twoArray, emptyArray));
1561 assertFalse(ArrayUtils.isSameLength(twoArray, oneArray));
1562 assertTrue(ArrayUtils.isSameLength(twoArray, twoArray));
1563 }
1564
1565 @Test
1566 public void testSameLengthByte() {
1567 final byte[] nullArray = null;
1568 final byte[] emptyArray = new byte[0];
1569 final byte[] oneArray = new byte[] {3};
1570 final byte[] twoArray = new byte[] {4, 6};
1571
1572 assertTrue(ArrayUtils.isSameLength(nullArray, nullArray));
1573 assertTrue(ArrayUtils.isSameLength(nullArray, emptyArray));
1574 assertFalse(ArrayUtils.isSameLength(nullArray, oneArray));
1575 assertFalse(ArrayUtils.isSameLength(nullArray, twoArray));
1576
1577 assertTrue(ArrayUtils.isSameLength(emptyArray, nullArray));
1578 assertTrue(ArrayUtils.isSameLength(emptyArray, emptyArray));
1579 assertFalse(ArrayUtils.isSameLength(emptyArray, oneArray));
1580 assertFalse(ArrayUtils.isSameLength(emptyArray, twoArray));
1581
1582 assertFalse(ArrayUtils.isSameLength(oneArray, nullArray));
1583 assertFalse(ArrayUtils.isSameLength(oneArray, emptyArray));
1584 assertTrue(ArrayUtils.isSameLength(oneArray, oneArray));
1585 assertFalse(ArrayUtils.isSameLength(oneArray, twoArray));
1586
1587 assertFalse(ArrayUtils.isSameLength(twoArray, nullArray));
1588 assertFalse(ArrayUtils.isSameLength(twoArray, emptyArray));
1589 assertFalse(ArrayUtils.isSameLength(twoArray, oneArray));
1590 assertTrue(ArrayUtils.isSameLength(twoArray, twoArray));
1591 }
1592
1593 @Test
1594 public void testSameLengthDouble() {
1595 final double[] nullArray = null;
1596 final double[] emptyArray = new double[0];
1597 final double[] oneArray = new double[] {1.3d};
1598 final double[] twoArray = new double[] {4.5d, 6.3d};
1599
1600 assertTrue(ArrayUtils.isSameLength(nullArray, nullArray));
1601 assertTrue(ArrayUtils.isSameLength(nullArray, emptyArray));
1602 assertFalse(ArrayUtils.isSameLength(nullArray, oneArray));
1603 assertFalse(ArrayUtils.isSameLength(nullArray, twoArray));
1604
1605 assertTrue(ArrayUtils.isSameLength(emptyArray, nullArray));
1606 assertTrue(ArrayUtils.isSameLength(emptyArray, emptyArray));
1607 assertFalse(ArrayUtils.isSameLength(emptyArray, oneArray));
1608 assertFalse(ArrayUtils.isSameLength(emptyArray, twoArray));
1609
1610 assertFalse(ArrayUtils.isSameLength(oneArray, nullArray));
1611 assertFalse(ArrayUtils.isSameLength(oneArray, emptyArray));
1612 assertTrue(ArrayUtils.isSameLength(oneArray, oneArray));
1613 assertFalse(ArrayUtils.isSameLength(oneArray, twoArray));
1614
1615 assertFalse(ArrayUtils.isSameLength(twoArray, nullArray));
1616 assertFalse(ArrayUtils.isSameLength(twoArray, emptyArray));
1617 assertFalse(ArrayUtils.isSameLength(twoArray, oneArray));
1618 assertTrue(ArrayUtils.isSameLength(twoArray, twoArray));
1619 }
1620
1621 @Test
1622 public void testSameLengthFloat() {
1623 final float[] nullArray = null;
1624 final float[] emptyArray = new float[0];
1625 final float[] oneArray = new float[] {2.5f};
1626 final float[] twoArray = new float[] {6.4f, 5.8f};
1627
1628 assertTrue(ArrayUtils.isSameLength(nullArray, nullArray));
1629 assertTrue(ArrayUtils.isSameLength(nullArray, emptyArray));
1630 assertFalse(ArrayUtils.isSameLength(nullArray, oneArray));
1631 assertFalse(ArrayUtils.isSameLength(nullArray, twoArray));
1632
1633 assertTrue(ArrayUtils.isSameLength(emptyArray, nullArray));
1634 assertTrue(ArrayUtils.isSameLength(emptyArray, emptyArray));
1635 assertFalse(ArrayUtils.isSameLength(emptyArray, oneArray));
1636 assertFalse(ArrayUtils.isSameLength(emptyArray, twoArray));
1637
1638 assertFalse(ArrayUtils.isSameLength(oneArray, nullArray));
1639 assertFalse(ArrayUtils.isSameLength(oneArray, emptyArray));
1640 assertTrue(ArrayUtils.isSameLength(oneArray, oneArray));
1641 assertFalse(ArrayUtils.isSameLength(oneArray, twoArray));
1642
1643 assertFalse(ArrayUtils.isSameLength(twoArray, nullArray));
1644 assertFalse(ArrayUtils.isSameLength(twoArray, emptyArray));
1645 assertFalse(ArrayUtils.isSameLength(twoArray, oneArray));
1646 assertTrue(ArrayUtils.isSameLength(twoArray, twoArray));
1647 }
1648
1649
1650 @Test
1651 public void testSameType() {
1652 try {
1653 ArrayUtils.isSameType(null, null);
1654 fail();
1655 } catch (final IllegalArgumentException ex) {}
1656 try {
1657 ArrayUtils.isSameType(null, new Object[0]);
1658 fail();
1659 } catch (final IllegalArgumentException ex) {}
1660 try {
1661 ArrayUtils.isSameType(new Object[0], null);
1662 fail();
1663 } catch (final IllegalArgumentException ex) {}
1664
1665 assertTrue(ArrayUtils.isSameType(new Object[0], new Object[0]));
1666 assertFalse(ArrayUtils.isSameType(new String[0], new Object[0]));
1667 assertTrue(ArrayUtils.isSameType(new String[0][0], new String[0][0]));
1668 assertFalse(ArrayUtils.isSameType(new String[0], new String[0][0]));
1669 assertFalse(ArrayUtils.isSameType(new String[0][0], new String[0]));
1670 }
1671
1672
1673 @Test
1674 public void testReverse() {
1675 final StringBuffer str1 = new StringBuffer("pick");
1676 final String str2 = "a";
1677 final String[] str3 = new String[] {"stick"};
1678 final String str4 = "up";
1679
1680 Object[] array = new Object[] {str1, str2, str3};
1681 ArrayUtils.reverse(array);
1682 assertEquals(array[0], str3);
1683 assertEquals(array[1], str2);
1684 assertEquals(array[2], str1);
1685
1686 array = new Object[] {str1, str2, str3, str4};
1687 ArrayUtils.reverse(array);
1688 assertEquals(array[0], str4);
1689 assertEquals(array[1], str3);
1690 assertEquals(array[2], str2);
1691 assertEquals(array[3], str1);
1692
1693 array = null;
1694 ArrayUtils.reverse(array);
1695 assertArrayEquals(null, array);
1696 }
1697
1698 @Test
1699 public void testReverseLong() {
1700 long[] array = new long[] {1L, 2L, 3L};
1701 ArrayUtils.reverse(array);
1702 assertEquals(array[0], 3L);
1703 assertEquals(array[1], 2L);
1704 assertEquals(array[2], 1L);
1705
1706 array = null;
1707 ArrayUtils.reverse(array);
1708 assertEquals(null, array);
1709 }
1710
1711 @Test
1712 public void testReverseInt() {
1713 int[] array = new int[] {1, 2, 3};
1714 ArrayUtils.reverse(array);
1715 assertEquals(array[0], 3);
1716 assertEquals(array[1], 2);
1717 assertEquals(array[2], 1);
1718
1719 array = null;
1720 ArrayUtils.reverse(array);
1721 assertEquals(null, array);
1722 }
1723
1724 @Test
1725 public void testReverseShort() {
1726 short[] array = new short[] {1, 2, 3};
1727 ArrayUtils.reverse(array);
1728 assertEquals(array[0], 3);
1729 assertEquals(array[1], 2);
1730 assertEquals(array[2], 1);
1731
1732 array = null;
1733 ArrayUtils.reverse(array);
1734 assertEquals(null, array);
1735 }
1736
1737 @Test
1738 public void testReverseChar() {
1739 char[] array = new char[] {'a', 'f', 'C'};
1740 ArrayUtils.reverse(array);
1741 assertEquals(array[0], 'C');
1742 assertEquals(array[1], 'f');
1743 assertEquals(array[2], 'a');
1744
1745 array = null;
1746 ArrayUtils.reverse(array);
1747 assertEquals(null, array);
1748 }
1749
1750 @Test
1751 public void testReverseByte() {
1752 byte[] array = new byte[] {2, 3, 4};
1753 ArrayUtils.reverse(array);
1754 assertEquals(array[0], 4);
1755 assertEquals(array[1], 3);
1756 assertEquals(array[2], 2);
1757
1758 array = null;
1759 ArrayUtils.reverse(array);
1760 assertEquals(null, array);
1761 }
1762
1763 @Test
1764 public void testReverseDouble() {
1765 double[] array = new double[] {0.3d, 0.4d, 0.5d};
1766 ArrayUtils.reverse(array);
1767 assertEquals(array[0], 0.5d, 0.0d);
1768 assertEquals(array[1], 0.4d, 0.0d);
1769 assertEquals(array[2], 0.3d, 0.0d);
1770
1771 array = null;
1772 ArrayUtils.reverse(array);
1773 assertEquals(null, array);
1774 }
1775
1776 @Test
1777 public void testReverseFloat() {
1778 float[] array = new float[] {0.3f, 0.4f, 0.5f};
1779 ArrayUtils.reverse(array);
1780 assertEquals(array[0], 0.5f, 0.0f);
1781 assertEquals(array[1], 0.4f, 0.0f);
1782 assertEquals(array[2], 0.3f, 0.0f);
1783
1784 array = null;
1785 ArrayUtils.reverse(array);
1786 assertEquals(null, array);
1787 }
1788
1789 @Test
1790 public void testReverseBoolean() {
1791 boolean[] array = new boolean[] {false, false, true};
1792 ArrayUtils.reverse(array);
1793 assertTrue(array[0]);
1794 assertFalse(array[1]);
1795 assertFalse(array[2]);
1796
1797 array = null;
1798 ArrayUtils.reverse(array);
1799 assertEquals(null, array);
1800 }
1801
1802 @Test
1803 public void testReverseBooleanRange() {
1804 boolean[] array = new boolean[] {false, false, true};
1805
1806 ArrayUtils.reverse(array, 0, 3);
1807 assertTrue(array[0]);
1808 assertFalse(array[1]);
1809 assertFalse(array[2]);
1810
1811 array = new boolean[] {false, false, true};
1812 ArrayUtils.reverse(array, 0, 2);
1813 assertFalse(array[0]);
1814 assertFalse(array[1]);
1815 assertTrue(array[2]);
1816
1817 array = new boolean[] {false, false, true};
1818 ArrayUtils.reverse(array, -1, 3);
1819 assertTrue(array[0]);
1820 assertFalse(array[1]);
1821 assertFalse(array[2]);
1822
1823 array = new boolean[] {false, false, true};
1824 ArrayUtils.reverse(array, -1, array.length + 1000);
1825 assertTrue(array[0]);
1826 assertFalse(array[1]);
1827 assertFalse(array[2]);
1828
1829 array = null;
1830 ArrayUtils.reverse(array, 0, 3);
1831 assertEquals(null, array);
1832 }
1833
1834 @Test
1835 public void testReverseByteRange() {
1836 byte[] array = new byte[] {1, 2, 3};
1837
1838 ArrayUtils.reverse(array, 0, 3);
1839 assertEquals(3, array[0]);
1840 assertEquals(2, array[1]);
1841 assertEquals(1, array[2]);
1842
1843 array = new byte[] {1, 2, 3};
1844 ArrayUtils.reverse(array, 0, 2);
1845 assertEquals(2, array[0]);
1846 assertEquals(1, array[1]);
1847 assertEquals(3, array[2]);
1848
1849 array = new byte[] {1, 2, 3};
1850 ArrayUtils.reverse(array, -1, 3);
1851 assertEquals(3, array[0]);
1852 assertEquals(2, array[1]);
1853 assertEquals(1, array[2]);
1854
1855 array = new byte[] {1, 2, 3};
1856 ArrayUtils.reverse(array, -1, array.length + 1000);
1857 assertEquals(3, array[0]);
1858 assertEquals(2, array[1]);
1859 assertEquals(1, array[2]);
1860
1861 array = null;
1862 ArrayUtils.reverse(array, 0, 3);
1863 assertEquals(null, array);
1864 }
1865
1866 @Test
1867 public void testReverseCharRange() {
1868 char[] array = new char[] {1, 2, 3};
1869
1870 ArrayUtils.reverse(array, 0, 3);
1871 assertEquals(3, array[0]);
1872 assertEquals(2, array[1]);
1873 assertEquals(1, array[2]);
1874
1875 array = new char[] {1, 2, 3};
1876 ArrayUtils.reverse(array, 0, 2);
1877 assertEquals(2, array[0]);
1878 assertEquals(1, array[1]);
1879 assertEquals(3, array[2]);
1880
1881 array = new char[] {1, 2, 3};
1882 ArrayUtils.reverse(array, -1, 3);
1883 assertEquals(3, array[0]);
1884 assertEquals(2, array[1]);
1885 assertEquals(1, array[2]);
1886
1887 array = new char[] {1, 2, 3};
1888 ArrayUtils.reverse(array, -1, array.length + 1000);
1889 assertEquals(3, array[0]);
1890 assertEquals(2, array[1]);
1891 assertEquals(1, array[2]);
1892
1893 array = null;
1894 ArrayUtils.reverse(array, 0, 3);
1895 assertEquals(null, array);
1896 }
1897
1898 @Test
1899 public void testReverseDoubleRange() {
1900 double[] array = new double[] {1, 2, 3};
1901
1902 ArrayUtils.reverse(array, 0, 3);
1903 assertEquals(3, array[0], 0);
1904 assertEquals(2, array[1], 0);
1905 assertEquals(1, array[2], 0);
1906
1907 array = new double[] {1, 2, 3};
1908 ArrayUtils.reverse(array, 0, 2);
1909 assertEquals(2, array[0], 0);
1910 assertEquals(1, array[1], 0);
1911 assertEquals(3, array[2], 0);
1912
1913 array = new double[] {1, 2, 3};
1914 ArrayUtils.reverse(array, -1, 3);
1915 assertEquals(3, array[0], 0);
1916 assertEquals(2, array[1], 0);
1917 assertEquals(1, array[2], 0);
1918
1919 array = new double[] {1, 2, 3};
1920 ArrayUtils.reverse(array, -1, array.length + 1000);
1921 assertEquals(3, array[0], 0);
1922 assertEquals(2, array[1], 0);
1923 assertEquals(1, array[2], 0);
1924
1925 array = null;
1926 ArrayUtils.reverse(array, 0, 3);
1927 assertEquals(null, array);
1928 }
1929
1930 @Test
1931 public void testReverseFloatRange() {
1932 float[] array = new float[] {1, 2, 3};
1933
1934 ArrayUtils.reverse(array, 0, 3);
1935 assertEquals(3, array[0], 0);
1936 assertEquals(2, array[1], 0);
1937 assertEquals(1, array[2], 0);
1938
1939 array = new float[] {1, 2, 3};
1940 ArrayUtils.reverse(array, 0, 2);
1941 assertEquals(2, array[0], 0);
1942 assertEquals(1, array[1], 0);
1943 assertEquals(3, array[2], 0);
1944
1945 array = new float[] {1, 2, 3};
1946 ArrayUtils.reverse(array, -1, 3);
1947 assertEquals(3, array[0], 0);
1948 assertEquals(2, array[1], 0);
1949 assertEquals(1, array[2], 0);
1950
1951 array = new float[] {1, 2, 3};
1952 ArrayUtils.reverse(array, -1, array.length + 1000);
1953 assertEquals(3, array[0], 0);
1954 assertEquals(2, array[1], 0);
1955 assertEquals(1, array[2], 0);
1956
1957 array = null;
1958 ArrayUtils.reverse(array, 0, 3);
1959 assertEquals(null, array);
1960 }
1961
1962 @Test
1963 public void testReverseIntRange() {
1964 int[] array = new int[] {1, 2, 3};
1965
1966 ArrayUtils.reverse(array, 0, 3);
1967 assertEquals(3, array[0]);
1968 assertEquals(2, array[1]);
1969 assertEquals(1, array[2]);
1970
1971 array = new int[] {1, 2, 3};
1972 ArrayUtils.reverse(array, 0, 2);
1973 assertEquals(2, array[0]);
1974 assertEquals(1, array[1]);
1975 assertEquals(3, array[2]);
1976
1977 array = new int[] {1, 2, 3};
1978 ArrayUtils.reverse(array, -1, 3);
1979 assertEquals(3, array[0]);
1980 assertEquals(2, array[1]);
1981 assertEquals(1, array[2]);
1982
1983 array = new int[] {1, 2, 3};
1984 ArrayUtils.reverse(array, -1, array.length + 1000);
1985 assertEquals(3, array[0]);
1986 assertEquals(2, array[1]);
1987 assertEquals(1, array[2]);
1988
1989 array = null;
1990 ArrayUtils.reverse(array, 0, 3);
1991 assertEquals(null, array);
1992 }
1993
1994 @Test
1995 public void testReverseLongRange() {
1996 long[] array = new long[] {1, 2, 3};
1997
1998 ArrayUtils.reverse(array, 0, 3);
1999 assertEquals(3, array[0]);
2000 assertEquals(2, array[1]);
2001 assertEquals(1, array[2]);
2002
2003 array = new long[] {1, 2, 3};
2004 ArrayUtils.reverse(array, 0, 2);
2005 assertEquals(2, array[0]);
2006 assertEquals(1, array[1]);
2007 assertEquals(3, array[2]);
2008
2009 array = new long[] {1, 2, 3};
2010 ArrayUtils.reverse(array, -1, 3);
2011 assertEquals(3, array[0]);
2012 assertEquals(2, array[1]);
2013 assertEquals(1, array[2]);
2014
2015 array = new long[] {1, 2, 3};
2016 ArrayUtils.reverse(array, -1, array.length + 1000);
2017 assertEquals(3, array[0]);
2018 assertEquals(2, array[1]);
2019 assertEquals(1, array[2]);
2020
2021 array = null;
2022 ArrayUtils.reverse(array, 0, 3);
2023 assertEquals(null, array);
2024 }
2025
2026 @Test
2027 public void testReverseShortRange() {
2028 short[] array = new short[] {1, 2, 3};
2029
2030 ArrayUtils.reverse(array, 0, 3);
2031 assertEquals(3, array[0]);
2032 assertEquals(2, array[1]);
2033 assertEquals(1, array[2]);
2034
2035 array = new short[] {1, 2, 3};
2036 ArrayUtils.reverse(array, 0, 2);
2037 assertEquals(2, array[0]);
2038 assertEquals(1, array[1]);
2039 assertEquals(3, array[2]);
2040
2041 array = new short[] {1, 2, 3};
2042 ArrayUtils.reverse(array, -1, 3);
2043 assertEquals(3, array[0]);
2044 assertEquals(2, array[1]);
2045 assertEquals(1, array[2]);
2046
2047 array = new short[] {1, 2, 3};
2048 ArrayUtils.reverse(array, -1, array.length + 1000);
2049 assertEquals(3, array[0]);
2050 assertEquals(2, array[1]);
2051 assertEquals(1, array[2]);
2052
2053 array = null;
2054 ArrayUtils.reverse(array, 0, 3);
2055 assertEquals(null, array);
2056 }
2057
2058 @Test
2059 public void testReverseObjectRange() {
2060 String[] array = new String[] {"1", "2", "3"};
2061
2062 ArrayUtils.reverse(array, 0, 3);
2063 assertEquals("3", array[0]);
2064 assertEquals("2", array[1]);
2065 assertEquals("1", array[2]);
2066
2067 array = new String[] {"1", "2", "3"};
2068 ArrayUtils.reverse(array, 0, 2);
2069 assertEquals("2", array[0]);
2070 assertEquals("1", array[1]);
2071 assertEquals("3", array[2]);
2072
2073 array = new String[] {"1", "2", "3"};
2074 ArrayUtils.reverse(array, -1, 3);
2075 assertEquals("3", array[0]);
2076 assertEquals("2", array[1]);
2077 assertEquals("1", array[2]);
2078
2079 array = new String[] {"1", "2", "3"};
2080 ArrayUtils.reverse(array, -1, array.length + 1000);
2081 assertEquals("3", array[0]);
2082 assertEquals("2", array[1]);
2083 assertEquals("1", array[2]);
2084
2085 array = null;
2086 ArrayUtils.reverse(array, 0, 3);
2087 assertEquals(null, array);
2088 }
2089
2090
2091
2092 @Test
2093 public void testIndexOf() {
2094 final Object[] array = new Object[] { "0", "1", "2", "3", null, "0" };
2095 assertEquals(-1, ArrayUtils.indexOf(null, null));
2096 assertEquals(-1, ArrayUtils.indexOf(null, "0"));
2097 assertEquals(-1, ArrayUtils.indexOf(new Object[0], "0"));
2098 assertEquals(0, ArrayUtils.indexOf(array, "0"));
2099 assertEquals(1, ArrayUtils.indexOf(array, "1"));
2100 assertEquals(2, ArrayUtils.indexOf(array, "2"));
2101 assertEquals(3, ArrayUtils.indexOf(array, "3"));
2102 assertEquals(4, ArrayUtils.indexOf(array, null));
2103 assertEquals(-1, ArrayUtils.indexOf(array, "notInArray"));
2104 }
2105
2106 @Test
2107 public void testIndexOfWithStartIndex() {
2108 final Object[] array = new Object[] { "0", "1", "2", "3", null, "0" };
2109 assertEquals(-1, ArrayUtils.indexOf(null, null, 2));
2110 assertEquals(-1, ArrayUtils.indexOf(new Object[0], "0", 0));
2111 assertEquals(-1, ArrayUtils.indexOf(null, "0", 2));
2112 assertEquals(5, ArrayUtils.indexOf(array, "0", 2));
2113 assertEquals(-1, ArrayUtils.indexOf(array, "1", 2));
2114 assertEquals(2, ArrayUtils.indexOf(array, "2", 2));
2115 assertEquals(3, ArrayUtils.indexOf(array, "3", 2));
2116 assertEquals(4, ArrayUtils.indexOf(array, null, 2));
2117 assertEquals(-1, ArrayUtils.indexOf(array, "notInArray", 2));
2118
2119 assertEquals(4, ArrayUtils.indexOf(array, null, -1));
2120 assertEquals(-1, ArrayUtils.indexOf(array, null, 8));
2121 assertEquals(-1, ArrayUtils.indexOf(array, "0", 8));
2122 }
2123
2124 @Test
2125 public void testLastIndexOf() {
2126 final Object[] array = new Object[] { "0", "1", "2", "3", null, "0" };
2127 assertEquals(-1, ArrayUtils.lastIndexOf(null, null));
2128 assertEquals(-1, ArrayUtils.lastIndexOf(null, "0"));
2129 assertEquals(5, ArrayUtils.lastIndexOf(array, "0"));
2130 assertEquals(1, ArrayUtils.lastIndexOf(array, "1"));
2131 assertEquals(2, ArrayUtils.lastIndexOf(array, "2"));
2132 assertEquals(3, ArrayUtils.lastIndexOf(array, "3"));
2133 assertEquals(4, ArrayUtils.lastIndexOf(array, null));
2134 assertEquals(-1, ArrayUtils.lastIndexOf(array, "notInArray"));
2135 }
2136
2137 @Test
2138 public void testLastIndexOfWithStartIndex() {
2139 final Object[] array = new Object[] { "0", "1", "2", "3", null, "0" };
2140 assertEquals(-1, ArrayUtils.lastIndexOf(null, null, 2));
2141 assertEquals(-1, ArrayUtils.lastIndexOf(null, "0", 2));
2142 assertEquals(0, ArrayUtils.lastIndexOf(array, "0", 2));
2143 assertEquals(1, ArrayUtils.lastIndexOf(array, "1", 2));
2144 assertEquals(2, ArrayUtils.lastIndexOf(array, "2", 2));
2145 assertEquals(-1, ArrayUtils.lastIndexOf(array, "3", 2));
2146 assertEquals(-1, ArrayUtils.lastIndexOf(array, "3", -1));
2147 assertEquals(4, ArrayUtils.lastIndexOf(array, null, 5));
2148 assertEquals(-1, ArrayUtils.lastIndexOf(array, null, 2));
2149 assertEquals(-1, ArrayUtils.lastIndexOf(array, "notInArray", 5));
2150
2151 assertEquals(-1, ArrayUtils.lastIndexOf(array, null, -1));
2152 assertEquals(5, ArrayUtils.lastIndexOf(array, "0", 88));
2153 }
2154
2155 @Test
2156 public void testContains() {
2157 final Object[] array = new Object[] { "0", "1", "2", "3", null, "0" };
2158 assertFalse(ArrayUtils.contains(null, null));
2159 assertFalse(ArrayUtils.contains(null, "1"));
2160 assertTrue(ArrayUtils.contains(array, "0"));
2161 assertTrue(ArrayUtils.contains(array, "1"));
2162 assertTrue(ArrayUtils.contains(array, "2"));
2163 assertTrue(ArrayUtils.contains(array, "3"));
2164 assertTrue(ArrayUtils.contains(array, null));
2165 assertFalse(ArrayUtils.contains(array, "notInArray"));
2166 }
2167
2168
2169 @Test
2170 public void testIndexOfLong() {
2171 long[] array = null;
2172 assertEquals(-1, ArrayUtils.indexOf(array, 0));
2173 array = new long[] { 0, 1, 2, 3, 0 };
2174 assertEquals(0, ArrayUtils.indexOf(array, 0));
2175 assertEquals(1, ArrayUtils.indexOf(array, 1));
2176 assertEquals(2, ArrayUtils.indexOf(array, 2));
2177 assertEquals(3, ArrayUtils.indexOf(array, 3));
2178 assertEquals(-1, ArrayUtils.indexOf(array, 99));
2179 }
2180
2181 @Test
2182 public void testIndexOfLongWithStartIndex() {
2183 long[] array = null;
2184 assertEquals(-1, ArrayUtils.indexOf(array, 0, 2));
2185 array = new long[] { 0, 1, 2, 3, 0 };
2186 assertEquals(4, ArrayUtils.indexOf(array, 0, 2));
2187 assertEquals(-1, ArrayUtils.indexOf(array, 1, 2));
2188 assertEquals(2, ArrayUtils.indexOf(array, 2, 2));
2189 assertEquals(3, ArrayUtils.indexOf(array, 3, 2));
2190 assertEquals(3, ArrayUtils.indexOf(array, 3, -1));
2191 assertEquals(-1, ArrayUtils.indexOf(array, 99, 0));
2192 assertEquals(-1, ArrayUtils.indexOf(array, 0, 6));
2193 }
2194
2195 @Test
2196 public void testLastIndexOfLong() {
2197 long[] array = null;
2198 assertEquals(-1, ArrayUtils.lastIndexOf(array, 0));
2199 array = new long[] { 0, 1, 2, 3, 0 };
2200 assertEquals(4, ArrayUtils.lastIndexOf(array, 0));
2201 assertEquals(1, ArrayUtils.lastIndexOf(array, 1));
2202 assertEquals(2, ArrayUtils.lastIndexOf(array, 2));
2203 assertEquals(3, ArrayUtils.lastIndexOf(array, 3));
2204 assertEquals(-1, ArrayUtils.lastIndexOf(array, 99));
2205 }
2206
2207 @Test
2208 public void testLastIndexOfLongWithStartIndex() {
2209 long[] array = null;
2210 assertEquals(-1, ArrayUtils.lastIndexOf(array, 0, 2));
2211 array = new long[] { 0, 1, 2, 3, 0 };
2212 assertEquals(0, ArrayUtils.lastIndexOf(array, 0, 2));
2213 assertEquals(1, ArrayUtils.lastIndexOf(array, 1, 2));
2214 assertEquals(2, ArrayUtils.lastIndexOf(array, 2, 2));
2215 assertEquals(-1, ArrayUtils.lastIndexOf(array, 3, 2));
2216 assertEquals(-1, ArrayUtils.lastIndexOf(array, 3, -1));
2217 assertEquals(-1, ArrayUtils.lastIndexOf(array, 99, 4));
2218 assertEquals(4, ArrayUtils.lastIndexOf(array, 0, 88));
2219 }
2220
2221 @Test
2222 public void testContainsLong() {
2223 long[] array = null;
2224 assertFalse(ArrayUtils.contains(array, 1));
2225 array = new long[] { 0, 1, 2, 3, 0 };
2226 assertTrue(ArrayUtils.contains(array, 0));
2227 assertTrue(ArrayUtils.contains(array, 1));
2228 assertTrue(ArrayUtils.contains(array, 2));
2229 assertTrue(ArrayUtils.contains(array, 3));
2230 assertFalse(ArrayUtils.contains(array, 99));
2231 }
2232
2233
2234 @Test
2235 public void testIndexOfInt() {
2236 int[] array = null;
2237 assertEquals(-1, ArrayUtils.indexOf(array, 0));
2238 array = new int[] { 0, 1, 2, 3, 0 };
2239 assertEquals(0, ArrayUtils.indexOf(array, 0));
2240 assertEquals(1, ArrayUtils.indexOf(array, 1));
2241 assertEquals(2, ArrayUtils.indexOf(array, 2));
2242 assertEquals(3, ArrayUtils.indexOf(array, 3));
2243 assertEquals(-1, ArrayUtils.indexOf(array, 99));
2244 }
2245
2246 @Test
2247 public void testIndexOfIntWithStartIndex() {
2248 int[] array = null;
2249 assertEquals(-1, ArrayUtils.indexOf(array, 0, 2));
2250 array = new int[] { 0, 1, 2, 3, 0 };
2251 assertEquals(4, ArrayUtils.indexOf(array, 0, 2));
2252 assertEquals(-1, ArrayUtils.indexOf(array, 1, 2));
2253 assertEquals(2, ArrayUtils.indexOf(array, 2, 2));
2254 assertEquals(3, ArrayUtils.indexOf(array, 3, 2));
2255 assertEquals(3, ArrayUtils.indexOf(array, 3, -1));
2256 assertEquals(-1, ArrayUtils.indexOf(array, 99, 0));
2257 assertEquals(-1, ArrayUtils.indexOf(array, 0, 6));
2258 }
2259
2260 @Test
2261 public void testLastIndexOfInt() {
2262 int[] array = null;
2263 assertEquals(-1, ArrayUtils.lastIndexOf(array, 0));
2264 array = new int[] { 0, 1, 2, 3, 0 };
2265 assertEquals(4, ArrayUtils.lastIndexOf(array, 0));
2266 assertEquals(1, ArrayUtils.lastIndexOf(array, 1));
2267 assertEquals(2, ArrayUtils.lastIndexOf(array, 2));
2268 assertEquals(3, ArrayUtils.lastIndexOf(array, 3));
2269 assertEquals(-1, ArrayUtils.lastIndexOf(array, 99));
2270 }
2271
2272 @Test
2273 public void testLastIndexOfIntWithStartIndex() {
2274 int[] array = null;
2275 assertEquals(-1, ArrayUtils.lastIndexOf(array, 0, 2));
2276 array = new int[] { 0, 1, 2, 3, 0 };
2277 assertEquals(0, ArrayUtils.lastIndexOf(array, 0, 2));
2278 assertEquals(1, ArrayUtils.lastIndexOf(array, 1, 2));
2279 assertEquals(2, ArrayUtils.lastIndexOf(array, 2, 2));
2280 assertEquals(-1, ArrayUtils.lastIndexOf(array, 3, 2));
2281 assertEquals(-1, ArrayUtils.lastIndexOf(array, 3, -1));
2282 assertEquals(-1, ArrayUtils.lastIndexOf(array, 99));
2283 assertEquals(4, ArrayUtils.lastIndexOf(array, 0, 88));
2284 }
2285
2286 @Test
2287 public void testContainsInt() {
2288 int[] array = null;
2289 assertFalse(ArrayUtils.contains(array, 1));
2290 array = new int[] { 0, 1, 2, 3, 0 };
2291 assertTrue(ArrayUtils.contains(array, 0));
2292 assertTrue(ArrayUtils.contains(array, 1));
2293 assertTrue(ArrayUtils.contains(array, 2));
2294 assertTrue(ArrayUtils.contains(array, 3));
2295 assertFalse(ArrayUtils.contains(array, 99));
2296 }
2297
2298
2299 @Test
2300 public void testIndexOfShort() {
2301 short[] array = null;
2302 assertEquals(-1, ArrayUtils.indexOf(array, (short) 0));
2303 array = new short[] { 0, 1, 2, 3, 0 };
2304 assertEquals(0, ArrayUtils.indexOf(array, (short) 0));
2305 assertEquals(1, ArrayUtils.indexOf(array, (short) 1));
2306 assertEquals(2, ArrayUtils.indexOf(array, (short) 2));
2307 assertEquals(3, ArrayUtils.indexOf(array, (short) 3));
2308 assertEquals(-1, ArrayUtils.indexOf(array, (short) 99));
2309 }
2310
2311 @Test
2312 public void testIndexOfShortWithStartIndex() {
2313 short[] array = null;
2314 assertEquals(-1, ArrayUtils.indexOf(array, (short) 0, 2));
2315 array = new short[] { 0, 1, 2, 3, 0 };
2316 assertEquals(4, ArrayUtils.indexOf(array, (short) 0, 2));
2317 assertEquals(-1, ArrayUtils.indexOf(array, (short) 1, 2));
2318 assertEquals(2, ArrayUtils.indexOf(array, (short) 2, 2));
2319 assertEquals(3, ArrayUtils.indexOf(array, (short) 3, 2));
2320 assertEquals(3, ArrayUtils.indexOf(array, (short) 3, -1));
2321 assertEquals(-1, ArrayUtils.indexOf(array, (short) 99, 0));
2322 assertEquals(-1, ArrayUtils.indexOf(array, (short) 0, 6));
2323 }
2324
2325 @Test
2326 public void testLastIndexOfShort() {
2327 short[] array = null;
2328 assertEquals(-1, ArrayUtils.lastIndexOf(array, (short) 0));
2329 array = new short[] { 0, 1, 2, 3, 0 };
2330 assertEquals(4, ArrayUtils.lastIndexOf(array, (short) 0));
2331 assertEquals(1, ArrayUtils.lastIndexOf(array, (short) 1));
2332 assertEquals(2, ArrayUtils.lastIndexOf(array, (short) 2));
2333 assertEquals(3, ArrayUtils.lastIndexOf(array, (short) 3));
2334 assertEquals(-1, ArrayUtils.lastIndexOf(array, (short) 99));
2335 }
2336
2337 @Test
2338 public void testLastIndexOfShortWithStartIndex() {
2339 short[] array = null;
2340 assertEquals(-1, ArrayUtils.lastIndexOf(array, (short) 0, 2));
2341 array = new short[] { 0, 1, 2, 3, 0 };
2342 assertEquals(0, ArrayUtils.lastIndexOf(array, (short) 0, 2));
2343 assertEquals(1, ArrayUtils.lastIndexOf(array, (short) 1, 2));
2344 assertEquals(2, ArrayUtils.lastIndexOf(array, (short) 2, 2));
2345 assertEquals(-1, ArrayUtils.lastIndexOf(array, (short) 3, 2));
2346 assertEquals(-1, ArrayUtils.lastIndexOf(array, (short) 3, -1));
2347 assertEquals(-1, ArrayUtils.lastIndexOf(array, (short) 99));
2348 assertEquals(4, ArrayUtils.lastIndexOf(array, (short) 0, 88));
2349 }
2350
2351 @Test
2352 public void testContainsShort() {
2353 short[] array = null;
2354 assertFalse(ArrayUtils.contains(array, (short) 1));
2355 array = new short[] { 0, 1, 2, 3, 0 };
2356 assertTrue(ArrayUtils.contains(array, (short) 0));
2357 assertTrue(ArrayUtils.contains(array, (short) 1));
2358 assertTrue(ArrayUtils.contains(array, (short) 2));
2359 assertTrue(ArrayUtils.contains(array, (short) 3));
2360 assertFalse(ArrayUtils.contains(array, (short) 99));
2361 }
2362
2363
2364 @Test
2365 public void testIndexOfChar() {
2366 char[] array = null;
2367 assertEquals(-1, ArrayUtils.indexOf(array, 'a'));
2368 array = new char[] { 'a', 'b', 'c', 'd', 'a' };
2369 assertEquals(0, ArrayUtils.indexOf(array, 'a'));
2370 assertEquals(1, ArrayUtils.indexOf(array, 'b'));
2371 assertEquals(2, ArrayUtils.indexOf(array, 'c'));
2372 assertEquals(3, ArrayUtils.indexOf(array, 'd'));
2373 assertEquals(-1, ArrayUtils.indexOf(array, 'e'));
2374 }
2375
2376 @Test
2377 public void testIndexOfCharWithStartIndex() {
2378 char[] array = null;
2379 assertEquals(-1, ArrayUtils.indexOf(array, 'a', 2));
2380 array = new char[] { 'a', 'b', 'c', 'd', 'a' };
2381 assertEquals(4, ArrayUtils.indexOf(array, 'a', 2));
2382 assertEquals(-1, ArrayUtils.indexOf(array, 'b', 2));
2383 assertEquals(2, ArrayUtils.indexOf(array, 'c', 2));
2384 assertEquals(3, ArrayUtils.indexOf(array, 'd', 2));
2385 assertEquals(3, ArrayUtils.indexOf(array, 'd', -1));
2386 assertEquals(-1, ArrayUtils.indexOf(array, 'e', 0));
2387 assertEquals(-1, ArrayUtils.indexOf(array, 'a', 6));
2388 }
2389
2390 @Test
2391 public void testLastIndexOfChar() {
2392 char[] array = null;
2393 assertEquals(-1, ArrayUtils.lastIndexOf(array, 'a'));
2394 array = new char[] { 'a', 'b', 'c', 'd', 'a' };
2395 assertEquals(4, ArrayUtils.lastIndexOf(array, 'a'));
2396 assertEquals(1, ArrayUtils.lastIndexOf(array, 'b'));
2397 assertEquals(2, ArrayUtils.lastIndexOf(array, 'c'));
2398 assertEquals(3, ArrayUtils.lastIndexOf(array, 'd'));
2399 assertEquals(-1, ArrayUtils.lastIndexOf(array, 'e'));
2400 }
2401
2402 @Test
2403 public void testLastIndexOfCharWithStartIndex() {
2404 char[] array = null;
2405 assertEquals(-1, ArrayUtils.lastIndexOf(array, 'a', 2));
2406 array = new char[] { 'a', 'b', 'c', 'd', 'a' };
2407 assertEquals(0, ArrayUtils.lastIndexOf(array, 'a', 2));
2408 assertEquals(1, ArrayUtils.lastIndexOf(array, 'b', 2));
2409 assertEquals(2, ArrayUtils.lastIndexOf(array, 'c', 2));
2410 assertEquals(-1, ArrayUtils.lastIndexOf(array, 'd', 2));
2411 assertEquals(-1, ArrayUtils.lastIndexOf(array, 'd', -1));
2412 assertEquals(-1, ArrayUtils.lastIndexOf(array, 'e'));
2413 assertEquals(4, ArrayUtils.lastIndexOf(array, 'a', 88));
2414 }
2415
2416 @Test
2417 public void testContainsChar() {
2418 char[] array = null;
2419 assertFalse(ArrayUtils.contains(array, 'b'));
2420 array = new char[] { 'a', 'b', 'c', 'd', 'a' };
2421 assertTrue(ArrayUtils.contains(array, 'a'));
2422 assertTrue(ArrayUtils.contains(array, 'b'));
2423 assertTrue(ArrayUtils.contains(array, 'c'));
2424 assertTrue(ArrayUtils.contains(array, 'd'));
2425 assertFalse(ArrayUtils.contains(array, 'e'));
2426 }
2427
2428
2429 @Test
2430 public void testIndexOfByte() {
2431 byte[] array = null;
2432 assertEquals(-1, ArrayUtils.indexOf(array, (byte) 0));
2433 array = new byte[] { 0, 1, 2, 3, 0 };
2434 assertEquals(0, ArrayUtils.indexOf(array, (byte) 0));
2435 assertEquals(1, ArrayUtils.indexOf(array, (byte) 1));
2436 assertEquals(2, ArrayUtils.indexOf(array, (byte) 2));
2437 assertEquals(3, ArrayUtils.indexOf(array, (byte) 3));
2438 assertEquals(-1, ArrayUtils.indexOf(array, (byte) 99));
2439 }
2440
2441 @Test
2442 public void testIndexOfByteWithStartIndex() {
2443 byte[] array = null;
2444 assertEquals(-1, ArrayUtils.indexOf(array, (byte) 0, 2));
2445 array = new byte[] { 0, 1, 2, 3, 0 };
2446 assertEquals(4, ArrayUtils.indexOf(array, (byte) 0, 2));
2447 assertEquals(-1, ArrayUtils.indexOf(array, (byte) 1, 2));
2448 assertEquals(2, ArrayUtils.indexOf(array, (byte) 2, 2));
2449 assertEquals(3, ArrayUtils.indexOf(array, (byte) 3, 2));
2450 assertEquals(3, ArrayUtils.indexOf(array, (byte) 3, -1));
2451 assertEquals(-1, ArrayUtils.indexOf(array, (byte) 99, 0));
2452 assertEquals(-1, ArrayUtils.indexOf(array, (byte) 0, 6));
2453 }
2454
2455 @Test
2456 public void testLastIndexOfByte() {
2457 byte[] array = null;
2458 assertEquals(-1, ArrayUtils.lastIndexOf(array, (byte) 0));
2459 array = new byte[] { 0, 1, 2, 3, 0 };
2460 assertEquals(4, ArrayUtils.lastIndexOf(array, (byte) 0));
2461 assertEquals(1, ArrayUtils.lastIndexOf(array, (byte) 1));
2462 assertEquals(2, ArrayUtils.lastIndexOf(array, (byte) 2));
2463 assertEquals(3, ArrayUtils.lastIndexOf(array, (byte) 3));
2464 assertEquals(-1, ArrayUtils.lastIndexOf(array, (byte) 99));
2465 }
2466
2467 @Test
2468 public void testLastIndexOfByteWithStartIndex() {
2469 byte[] array = null;
2470 assertEquals(-1, ArrayUtils.lastIndexOf(array, (byte) 0, 2));
2471 array = new byte[] { 0, 1, 2, 3, 0 };
2472 assertEquals(0, ArrayUtils.lastIndexOf(array, (byte) 0, 2));
2473 assertEquals(1, ArrayUtils.lastIndexOf(array, (byte) 1, 2));
2474 assertEquals(2, ArrayUtils.lastIndexOf(array, (byte) 2, 2));
2475 assertEquals(-1, ArrayUtils.lastIndexOf(array, (byte) 3, 2));
2476 assertEquals(-1, ArrayUtils.lastIndexOf(array, (byte) 3, -1));
2477 assertEquals(-1, ArrayUtils.lastIndexOf(array, (byte) 99));
2478 assertEquals(4, ArrayUtils.lastIndexOf(array, (byte) 0, 88));
2479 }
2480
2481 @Test
2482 public void testContainsByte() {
2483 byte[] array = null;
2484 assertFalse(ArrayUtils.contains(array, (byte) 1));
2485 array = new byte[] { 0, 1, 2, 3, 0 };
2486 assertTrue(ArrayUtils.contains(array, (byte) 0));
2487 assertTrue(ArrayUtils.contains(array, (byte) 1));
2488 assertTrue(ArrayUtils.contains(array, (byte) 2));
2489 assertTrue(ArrayUtils.contains(array, (byte) 3));
2490 assertFalse(ArrayUtils.contains(array, (byte) 99));
2491 }
2492
2493
2494 @SuppressWarnings("cast")
2495 @Test
2496 public void testIndexOfDouble() {
2497 double[] array = null;
2498 assertEquals(-1, ArrayUtils.indexOf(array, (double) 0));
2499 array = new double[0];
2500 assertEquals(-1, ArrayUtils.indexOf(array, (double) 0));
2501 array = new double[] { 0, 1, 2, 3, 0 };
2502 assertEquals(0, ArrayUtils.indexOf(array, (double) 0));
2503 assertEquals(1, ArrayUtils.indexOf(array, (double) 1));
2504 assertEquals(2, ArrayUtils.indexOf(array, (double) 2));
2505 assertEquals(3, ArrayUtils.indexOf(array, (double) 3));
2506 assertEquals(3, ArrayUtils.indexOf(array, (double) 3, -1));
2507 assertEquals(-1, ArrayUtils.indexOf(array, (double) 99));
2508 }
2509
2510 @SuppressWarnings("cast")
2511 @Test
2512 public void testIndexOfDoubleTolerance() {
2513 double[] array = null;
2514 assertEquals(-1, ArrayUtils.indexOf(array, (double) 0, (double) 0));
2515 array = new double[0];
2516 assertEquals(-1, ArrayUtils.indexOf(array, (double) 0, (double) 0));
2517 array = new double[] { 0, 1, 2, 3, 0 };
2518 assertEquals(0, ArrayUtils.indexOf(array, (double) 0, (double) 0.3));
2519 assertEquals(2, ArrayUtils.indexOf(array, (double) 2.2, (double) 0.35));
2520 assertEquals(3, ArrayUtils.indexOf(array, (double) 4.15, (double) 2.0));
2521 assertEquals(1, ArrayUtils.indexOf(array, (double) 1.00001324, (double) 0.0001));
2522 }
2523
2524 @SuppressWarnings("cast")
2525 @Test
2526 public void testIndexOfDoubleWithStartIndex() {
2527 double[] array = null;
2528 assertEquals(-1, ArrayUtils.indexOf(array, (double) 0, 2));
2529 array = new double[0];
2530 assertEquals(-1, ArrayUtils.indexOf(array, (double) 0, 2));
2531 array = new double[] { 0, 1, 2, 3, 0 };
2532 assertEquals(4, ArrayUtils.indexOf(array, (double) 0, 2));
2533 assertEquals(-1, ArrayUtils.indexOf(array, (double) 1, 2));
2534 assertEquals(2, ArrayUtils.indexOf(array, (double) 2, 2));
2535 assertEquals(3, ArrayUtils.indexOf(array, (double) 3, 2));
2536 assertEquals(-1, ArrayUtils.indexOf(array, (double) 99, 0));
2537 assertEquals(-1, ArrayUtils.indexOf(array, (double) 0, 6));
2538 }
2539
2540 @SuppressWarnings("cast")
2541 @Test
2542 public void testIndexOfDoubleWithStartIndexTolerance() {
2543 double[] array = null;
2544 assertEquals(-1, ArrayUtils.indexOf(array, (double) 0, 2, (double) 0));
2545 array = new double[0];
2546 assertEquals(-1, ArrayUtils.indexOf(array, (double) 0, 2, (double) 0));
2547 array = new double[] { 0, 1, 2, 3, 0 };
2548 assertEquals(-1, ArrayUtils.indexOf(array, (double) 0, 99, (double) 0.3));
2549 assertEquals(0, ArrayUtils.indexOf(array, (double) 0, 0, (double) 0.3));
2550 assertEquals(4, ArrayUtils.indexOf(array, (double) 0, 3, (double) 0.3));
2551 assertEquals(2, ArrayUtils.indexOf(array, (double) 2.2, 0, (double) 0.35));
2552 assertEquals(3, ArrayUtils.indexOf(array, (double) 4.15, 0, (double) 2.0));
2553 assertEquals(1, ArrayUtils.indexOf(array, (double) 1.00001324, 0, (double) 0.0001));
2554 assertEquals(3, ArrayUtils.indexOf(array, (double) 4.15, -1, (double) 2.0));
2555 assertEquals(1, ArrayUtils.indexOf(array, (double) 1.00001324, -300, (double) 0.0001));
2556 }
2557
2558 @SuppressWarnings("cast")
2559 @Test
2560 public void testLastIndexOfDouble() {
2561 double[] array = null;
2562 assertEquals(-1, ArrayUtils.lastIndexOf(array, (double) 0));
2563 array = new double[0];
2564 assertEquals(-1, ArrayUtils.lastIndexOf(array, (double) 0));
2565 array = new double[] { 0, 1, 2, 3, 0 };
2566 assertEquals(4, ArrayUtils.lastIndexOf(array, (double) 0));
2567 assertEquals(1, ArrayUtils.lastIndexOf(array, (double) 1));
2568 assertEquals(2, ArrayUtils.lastIndexOf(array, (double) 2));
2569 assertEquals(3, ArrayUtils.lastIndexOf(array, (double) 3));
2570 assertEquals(-1, ArrayUtils.lastIndexOf(array, (double) 99));
2571 }
2572
2573 @SuppressWarnings("cast")
2574 @Test
2575 public void testLastIndexOfDoubleTolerance() {
2576 double[] array = null;
2577 assertEquals(-1, ArrayUtils.lastIndexOf(array, (double) 0, (double) 0));
2578 array = new double[0];
2579 assertEquals(-1, ArrayUtils.lastIndexOf(array, (double) 0, (double) 0));
2580 array = new double[] { 0, 1, 2, 3, 0 };
2581 assertEquals(4, ArrayUtils.lastIndexOf(array, (double) 0, (double) 0.3));
2582 assertEquals(2, ArrayUtils.lastIndexOf(array, (double) 2.2, (double) 0.35));
2583 assertEquals(3, ArrayUtils.lastIndexOf(array, (double) 4.15, (double) 2.0));
2584 assertEquals(1, ArrayUtils.lastIndexOf(array, (double) 1.00001324, (double) 0.0001));
2585 }
2586
2587 @SuppressWarnings("cast")
2588 @Test
2589 public void testLastIndexOfDoubleWithStartIndex() {
2590 double[] array = null;
2591 assertEquals(-1, ArrayUtils.lastIndexOf(array, (double) 0, 2));
2592 array = new double[0];
2593 assertEquals(-1, ArrayUtils.lastIndexOf(array, (double) 0, 2));
2594 array = new double[] { 0, 1, 2, 3, 0 };
2595 assertEquals(0, ArrayUtils.lastIndexOf(array, (double) 0, 2));
2596 assertEquals(1, ArrayUtils.lastIndexOf(array, (double) 1, 2));
2597 assertEquals(2, ArrayUtils.lastIndexOf(array, (double) 2, 2));
2598 assertEquals(-1, ArrayUtils.lastIndexOf(array, (double) 3, 2));
2599 assertEquals(-1, ArrayUtils.lastIndexOf(array, (double) 3, -1));
2600 assertEquals(-1, ArrayUtils.lastIndexOf(array, (double) 99));
2601 assertEquals(4, ArrayUtils.lastIndexOf(array, (double) 0, 88));
2602 }
2603
2604 @SuppressWarnings("cast")
2605 @Test
2606 public void testLastIndexOfDoubleWithStartIndexTolerance() {
2607 double[] array = null;
2608 assertEquals(-1, ArrayUtils.lastIndexOf(array, (double) 0, 2, (double) 0));
2609 array = new double[0];
2610 assertEquals(-1, ArrayUtils.lastIndexOf(array, (double) 0, 2, (double) 0));
2611 array = new double[] { (double) 3 };
2612 assertEquals(-1, ArrayUtils.lastIndexOf(array, (double) 1, 0, (double) 0));
2613 array = new double[] { 0, 1, 2, 3, 0 };
2614 assertEquals(4, ArrayUtils.lastIndexOf(array, (double) 0, 99, (double) 0.3));
2615 assertEquals(0, ArrayUtils.lastIndexOf(array, (double) 0, 3, (double) 0.3));
2616 assertEquals(2, ArrayUtils.lastIndexOf(array, (double) 2.2, 3, (double) 0.35));
2617 assertEquals(3, ArrayUtils.lastIndexOf(array, (double) 4.15, array.length, (double) 2.0));
2618 assertEquals(1, ArrayUtils.lastIndexOf(array, (double) 1.00001324, array.length, (double) 0.0001));
2619 assertEquals(-1, ArrayUtils.lastIndexOf(array, (double) 4.15, -200, (double) 2.0));
2620 }
2621
2622 @SuppressWarnings("cast")
2623 @Test
2624 public void testContainsDouble() {
2625 double[] array = null;
2626 assertFalse(ArrayUtils.contains(array, (double) 1));
2627 array = new double[] { 0, 1, 2, 3, 0 };
2628 assertTrue(ArrayUtils.contains(array, (double) 0));
2629 assertTrue(ArrayUtils.contains(array, (double) 1));
2630 assertTrue(ArrayUtils.contains(array, (double) 2));
2631 assertTrue(ArrayUtils.contains(array, (double) 3));
2632 assertFalse(ArrayUtils.contains(array, (double) 99));
2633 }
2634
2635 @SuppressWarnings("cast")
2636 @Test
2637 public void testContainsDoubleTolerance() {
2638 double[] array = null;
2639 assertFalse(ArrayUtils.contains(array, (double) 1, (double) 0));
2640 array = new double[] { 0, 1, 2, 3, 0 };
2641 assertFalse(ArrayUtils.contains(array, (double) 4.0, (double) 0.33));
2642 assertFalse(ArrayUtils.contains(array, (double) 2.5, (double) 0.49));
2643 assertTrue(ArrayUtils.contains(array, (double) 2.5, (double) 0.50));
2644 assertTrue(ArrayUtils.contains(array, (double) 2.5, (double) 0.51));
2645 }
2646
2647
2648 @SuppressWarnings("cast")
2649 @Test
2650 public void testIndexOfFloat() {
2651 float[] array = null;
2652 assertEquals(-1, ArrayUtils.indexOf(array, (float) 0));
2653 array = new float[0];
2654 assertEquals(-1, ArrayUtils.indexOf(array, (float) 0));
2655 array = new float[] { 0, 1, 2, 3, 0 };
2656 assertEquals(0, ArrayUtils.indexOf(array, (float) 0));
2657 assertEquals(1, ArrayUtils.indexOf(array, (float) 1));
2658 assertEquals(2, ArrayUtils.indexOf(array, (float) 2));
2659 assertEquals(3, ArrayUtils.indexOf(array, (float) 3));
2660 assertEquals(-1, ArrayUtils.indexOf(array, (float) 99));
2661 }
2662
2663 @SuppressWarnings("cast")
2664 @Test
2665 public void testIndexOfFloatWithStartIndex() {
2666 float[] array = null;
2667 assertEquals(-1, ArrayUtils.indexOf(array, (float) 0, 2));
2668 array = new float[0];
2669 assertEquals(-1, ArrayUtils.indexOf(array, (float) 0, 2));
2670 array = new float[] { 0, 1, 2, 3, 0 };
2671 assertEquals(4, ArrayUtils.indexOf(array, (float) 0, 2));
2672 assertEquals(-1, ArrayUtils.indexOf(array, (float) 1, 2));
2673 assertEquals(2, ArrayUtils.indexOf(array, (float) 2, 2));
2674 assertEquals(3, ArrayUtils.indexOf(array, (float) 3, 2));
2675 assertEquals(3, ArrayUtils.indexOf(array, (float) 3, -1));
2676 assertEquals(-1, ArrayUtils.indexOf(array, (float) 99, 0));
2677 assertEquals(-1, ArrayUtils.indexOf(array, (float) 0, 6));
2678 }
2679
2680 @SuppressWarnings("cast")
2681 @Test
2682 public void testLastIndexOfFloat() {
2683 float[] array = null;
2684 assertEquals(-1, ArrayUtils.lastIndexOf(array, (float) 0));
2685 array = new float[0];
2686 assertEquals(-1, ArrayUtils.lastIndexOf(array, (float) 0));
2687 array = new float[] { 0, 1, 2, 3, 0 };
2688 assertEquals(4, ArrayUtils.lastIndexOf(array, (float) 0));
2689 assertEquals(1, ArrayUtils.lastIndexOf(array, (float) 1));
2690 assertEquals(2, ArrayUtils.lastIndexOf(array, (float) 2));
2691 assertEquals(3, ArrayUtils.lastIndexOf(array, (float) 3));
2692 assertEquals(-1, ArrayUtils.lastIndexOf(array, (float) 99));
2693 }
2694
2695 @SuppressWarnings("cast")
2696 @Test
2697 public void testLastIndexOfFloatWithStartIndex() {
2698 float[] array = null;
2699 assertEquals(-1, ArrayUtils.lastIndexOf(array, (float) 0, 2));
2700 array = new float[0];
2701 assertEquals(-1, ArrayUtils.lastIndexOf(array, (float) 0, 2));
2702 array = new float[] { 0, 1, 2, 3, 0 };
2703 assertEquals(0, ArrayUtils.lastIndexOf(array, (float) 0, 2));
2704 assertEquals(1, ArrayUtils.lastIndexOf(array, (float) 1, 2));
2705 assertEquals(2, ArrayUtils.lastIndexOf(array, (float) 2, 2));
2706 assertEquals(-1, ArrayUtils.lastIndexOf(array, (float) 3, 2));
2707 assertEquals(-1, ArrayUtils.lastIndexOf(array, (float) 3, -1));
2708 assertEquals(-1, ArrayUtils.lastIndexOf(array, (float) 99));
2709 assertEquals(4, ArrayUtils.lastIndexOf(array, (float) 0, 88));
2710 }
2711
2712 @SuppressWarnings("cast")
2713 @Test
2714 public void testContainsFloat() {
2715 float[] array = null;
2716 assertFalse(ArrayUtils.contains(array, (float) 1));
2717 array = new float[] { 0, 1, 2, 3, 0 };
2718 assertTrue(ArrayUtils.contains(array, (float) 0));
2719 assertTrue(ArrayUtils.contains(array, (float) 1));
2720 assertTrue(ArrayUtils.contains(array, (float) 2));
2721 assertTrue(ArrayUtils.contains(array, (float) 3));
2722 assertFalse(ArrayUtils.contains(array, (float) 99));
2723 }
2724
2725
2726 @Test
2727 public void testIndexOfBoolean() {
2728 boolean[] array = null;
2729 assertEquals(-1, ArrayUtils.indexOf(array, true));
2730 array = new boolean[0];
2731 assertEquals(-1, ArrayUtils.indexOf(array, true));
2732 array = new boolean[] { true, false, true };
2733 assertEquals(0, ArrayUtils.indexOf(array, true));
2734 assertEquals(1, ArrayUtils.indexOf(array, false));
2735 array = new boolean[] { true, true };
2736 assertEquals(-1, ArrayUtils.indexOf(array, false));
2737 }
2738
2739 @Test
2740 public void testIndexOfBooleanWithStartIndex() {
2741 boolean[] array = null;
2742 assertEquals(-1, ArrayUtils.indexOf(array, true, 2));
2743 array = new boolean[0];
2744 assertEquals(-1, ArrayUtils.indexOf(array, true, 2));
2745 array = new boolean[] { true, false, true };
2746 assertEquals(2, ArrayUtils.indexOf(array, true, 1));
2747 assertEquals(-1, ArrayUtils.indexOf(array, false, 2));
2748 assertEquals(1, ArrayUtils.indexOf(array, false, 0));
2749 assertEquals(1, ArrayUtils.indexOf(array, false, -1));
2750 array = new boolean[] { true, true };
2751 assertEquals(-1, ArrayUtils.indexOf(array, false, 0));
2752 assertEquals(-1, ArrayUtils.indexOf(array, false, -1));
2753 }
2754
2755 @Test
2756 public void testLastIndexOfBoolean() {
2757 boolean[] array = null;
2758 assertEquals(-1, ArrayUtils.lastIndexOf(array, true));
2759 array = new boolean[0];
2760 assertEquals(-1, ArrayUtils.lastIndexOf(array, true));
2761 array = new boolean[] { true, false, true };
2762 assertEquals(2, ArrayUtils.lastIndexOf(array, true));
2763 assertEquals(1, ArrayUtils.lastIndexOf(array, false));
2764 array = new boolean[] { true, true };
2765 assertEquals(-1, ArrayUtils.lastIndexOf(array, false));
2766 }
2767
2768 @Test
2769 public void testLastIndexOfBooleanWithStartIndex() {
2770 boolean[] array = null;
2771 assertEquals(-1, ArrayUtils.lastIndexOf(array, true, 2));
2772 array = new boolean[0];
2773 assertEquals(-1, ArrayUtils.lastIndexOf(array, true, 2));
2774 array = new boolean[] { true, false, true };
2775 assertEquals(2, ArrayUtils.lastIndexOf(array, true, 2));
2776 assertEquals(0, ArrayUtils.lastIndexOf(array, true, 1));
2777 assertEquals(1, ArrayUtils.lastIndexOf(array, false, 2));
2778 assertEquals(-1, ArrayUtils.lastIndexOf(array, true, -1));
2779 array = new boolean[] { true, true };
2780 assertEquals(-1, ArrayUtils.lastIndexOf(array, false, 2));
2781 assertEquals(-1, ArrayUtils.lastIndexOf(array, true, -1));
2782 }
2783
2784 @Test
2785 public void testContainsBoolean() {
2786 boolean[] array = null;
2787 assertFalse(ArrayUtils.contains(array, true));
2788 array = new boolean[] { true, false, true };
2789 assertTrue(ArrayUtils.contains(array, true));
2790 assertTrue(ArrayUtils.contains(array, false));
2791 array = new boolean[] { true, true };
2792 assertTrue(ArrayUtils.contains(array, true));
2793 assertFalse(ArrayUtils.contains(array, false));
2794 }
2795
2796
2797
2798 @Test
2799 public void testToPrimitive_boolean() {
2800 final Boolean[] b = null;
2801 assertEquals(null, ArrayUtils.toPrimitive(b));
2802 assertSame(ArrayUtils.EMPTY_BOOLEAN_ARRAY, ArrayUtils.toPrimitive(new Boolean[0]));
2803 assertTrue(Arrays.equals(
2804 new boolean[] {true, false, true},
2805 ArrayUtils.toPrimitive(new Boolean[] {Boolean.TRUE, Boolean.FALSE, Boolean.TRUE}))
2806 );
2807
2808 try {
2809 ArrayUtils.toPrimitive(new Boolean[] {Boolean.TRUE, null});
2810 fail();
2811 } catch (final NullPointerException ex) {}
2812 }
2813
2814 @Test
2815 public void testToPrimitive_boolean_boolean() {
2816 assertEquals(null, ArrayUtils.toPrimitive(null, false));
2817 assertSame(ArrayUtils.EMPTY_BOOLEAN_ARRAY, ArrayUtils.toPrimitive(new Boolean[0], false));
2818 assertTrue(Arrays.equals(
2819 new boolean[] {true, false, true},
2820 ArrayUtils.toPrimitive(new Boolean[] {Boolean.TRUE, Boolean.FALSE, Boolean.TRUE}, false))
2821 );
2822 assertTrue(Arrays.equals(
2823 new boolean[] {true, false, false},
2824 ArrayUtils.toPrimitive(new Boolean[] {Boolean.TRUE, null, Boolean.FALSE}, false))
2825 );
2826 assertTrue(Arrays.equals(
2827 new boolean[] {true, true, false},
2828 ArrayUtils.toPrimitive(new Boolean[] {Boolean.TRUE, null, Boolean.FALSE}, true))
2829 );
2830 }
2831
2832 @Test
2833 public void testToObject_boolean() {
2834 final boolean[] b = null;
2835 assertArrayEquals(null, ArrayUtils.toObject(b));
2836 assertSame(ArrayUtils.EMPTY_BOOLEAN_OBJECT_ARRAY, ArrayUtils.toObject(new boolean[0]));
2837 assertTrue(Arrays.equals(
2838 new Boolean[] {Boolean.TRUE, Boolean.FALSE, Boolean.TRUE},
2839 ArrayUtils.toObject(new boolean[] {true, false, true}))
2840 );
2841 }
2842
2843
2844
2845 @Test
2846 public void testToPrimitive_char() {
2847 final Character[] b = null;
2848 assertEquals(null, ArrayUtils.toPrimitive(b));
2849
2850 assertSame(ArrayUtils.EMPTY_CHAR_ARRAY, ArrayUtils.toPrimitive(new Character[0]));
2851
2852 assertTrue(Arrays.equals(
2853 new char[] {Character.MIN_VALUE, Character.MAX_VALUE, '0'},
2854 ArrayUtils.toPrimitive(new Character[] {new Character(Character.MIN_VALUE),
2855 new Character(Character.MAX_VALUE), new Character('0')}))
2856 );
2857
2858 try {
2859 ArrayUtils.toPrimitive(new Character[] {new Character(Character.MIN_VALUE), null});
2860 fail();
2861 } catch (final NullPointerException ex) {}
2862 }
2863
2864 @Test
2865 public void testToPrimitive_char_char() {
2866 final Character[] b = null;
2867 assertEquals(null, ArrayUtils.toPrimitive(b, Character.MIN_VALUE));
2868
2869 assertSame(ArrayUtils.EMPTY_CHAR_ARRAY,
2870 ArrayUtils.toPrimitive(new Character[0], (char)0));
2871
2872 assertTrue(Arrays.equals(
2873 new char[] {Character.MIN_VALUE, Character.MAX_VALUE, '0'},
2874 ArrayUtils.toPrimitive(new Character[] {new Character(Character.MIN_VALUE),
2875 new Character(Character.MAX_VALUE), new Character('0')},
2876 Character.MIN_VALUE))
2877 );
2878
2879 assertTrue(Arrays.equals(
2880 new char[] {Character.MIN_VALUE, Character.MAX_VALUE, '0'},
2881 ArrayUtils.toPrimitive(new Character[] {new Character(Character.MIN_VALUE), null,
2882 new Character('0')}, Character.MAX_VALUE))
2883 );
2884 }
2885
2886 @Test
2887 public void testToObject_char() {
2888 final char[] b = null;
2889 assertArrayEquals(null, ArrayUtils.toObject(b));
2890
2891 assertSame(ArrayUtils.EMPTY_CHARACTER_OBJECT_ARRAY,
2892 ArrayUtils.toObject(new char[0]));
2893
2894 assertTrue(Arrays.equals(
2895 new Character[] {new Character(Character.MIN_VALUE),
2896 new Character(Character.MAX_VALUE), new Character('0')},
2897 ArrayUtils.toObject(new char[] {Character.MIN_VALUE, Character.MAX_VALUE,
2898 '0'} ))
2899 );
2900 }
2901
2902
2903
2904 @Test
2905 public void testToPrimitive_byte() {
2906 final Byte[] b = null;
2907 assertEquals(null, ArrayUtils.toPrimitive(b));
2908
2909 assertSame(ArrayUtils.EMPTY_BYTE_ARRAY, ArrayUtils.toPrimitive(new Byte[0]));
2910
2911 assertTrue(Arrays.equals(
2912 new byte[] {Byte.MIN_VALUE, Byte.MAX_VALUE, (byte)9999999},
2913 ArrayUtils.toPrimitive(new Byte[] {Byte.valueOf(Byte.MIN_VALUE),
2914 Byte.valueOf(Byte.MAX_VALUE), Byte.valueOf((byte)9999999)}))
2915 );
2916
2917 try {
2918 ArrayUtils.toPrimitive(new Byte[] {Byte.valueOf(Byte.MIN_VALUE), null});
2919 fail();
2920 } catch (final NullPointerException ex) {}
2921 }
2922
2923 @Test
2924 public void testToPrimitive_byte_byte() {
2925 final Byte[] b = null;
2926 assertEquals(null, ArrayUtils.toPrimitive(b, Byte.MIN_VALUE));
2927
2928 assertSame(ArrayUtils.EMPTY_BYTE_ARRAY,
2929 ArrayUtils.toPrimitive(new Byte[0], (byte)1));
2930
2931 assertTrue(Arrays.equals(
2932 new byte[] {Byte.MIN_VALUE, Byte.MAX_VALUE, (byte)9999999},
2933 ArrayUtils.toPrimitive(new Byte[] {Byte.valueOf(Byte.MIN_VALUE),
2934 Byte.valueOf(Byte.MAX_VALUE), Byte.valueOf((byte)9999999)},
2935 Byte.MIN_VALUE))
2936 );
2937
2938 assertTrue(Arrays.equals(
2939 new byte[] {Byte.MIN_VALUE, Byte.MAX_VALUE, (byte)9999999},
2940 ArrayUtils.toPrimitive(new Byte[] {Byte.valueOf(Byte.MIN_VALUE), null,
2941 Byte.valueOf((byte)9999999)}, Byte.MAX_VALUE))
2942 );
2943 }
2944
2945 @Test
2946 public void testToObject_byte() {
2947 final byte[] b = null;
2948 assertArrayEquals(null, ArrayUtils.toObject(b));
2949
2950 assertSame(ArrayUtils.EMPTY_BYTE_OBJECT_ARRAY,
2951 ArrayUtils.toObject(new byte[0]));
2952
2953 assertTrue(Arrays.equals(
2954 new Byte[] {Byte.valueOf(Byte.MIN_VALUE),
2955 Byte.valueOf(Byte.MAX_VALUE), Byte.valueOf((byte)9999999)},
2956 ArrayUtils.toObject(new byte[] {Byte.MIN_VALUE, Byte.MAX_VALUE,
2957 (byte)9999999}))
2958 );
2959 }
2960
2961
2962
2963 @Test
2964 public void testToPrimitive_short() {
2965 final Short[] b = null;
2966 assertEquals(null, ArrayUtils.toPrimitive(b));
2967
2968 assertSame(ArrayUtils.EMPTY_SHORT_ARRAY, ArrayUtils.toPrimitive(new Short[0]));
2969
2970 assertTrue(Arrays.equals(
2971 new short[] {Short.MIN_VALUE, Short.MAX_VALUE, (short)9999999},
2972 ArrayUtils.toPrimitive(new Short[] {Short.valueOf(Short.MIN_VALUE),
2973 Short.valueOf(Short.MAX_VALUE), Short.valueOf((short)9999999)}))
2974 );
2975
2976 try {
2977 ArrayUtils.toPrimitive(new Short[] {Short.valueOf(Short.MIN_VALUE), null});
2978 fail();
2979 } catch (final NullPointerException ex) {}
2980 }
2981
2982 @Test
2983 public void testToPrimitive_short_short() {
2984 final Short[] s = null;
2985 assertEquals(null, ArrayUtils.toPrimitive(s, Short.MIN_VALUE));
2986
2987 assertSame(ArrayUtils.EMPTY_SHORT_ARRAY, ArrayUtils.toPrimitive(new Short[0],
2988 Short.MIN_VALUE));
2989
2990 assertTrue(Arrays.equals(
2991 new short[] {Short.MIN_VALUE, Short.MAX_VALUE, (short)9999999},
2992 ArrayUtils.toPrimitive(new Short[] {Short.valueOf(Short.MIN_VALUE),
2993 Short.valueOf(Short.MAX_VALUE), Short.valueOf((short)9999999)}, Short.MIN_VALUE))
2994 );
2995
2996 assertTrue(Arrays.equals(
2997 new short[] {Short.MIN_VALUE, Short.MAX_VALUE, (short)9999999},
2998 ArrayUtils.toPrimitive(new Short[] {Short.valueOf(Short.MIN_VALUE), null,
2999 Short.valueOf((short)9999999)}, Short.MAX_VALUE))
3000 );
3001 }
3002
3003 @Test
3004 public void testToObject_short() {
3005 final short[] b = null;
3006 assertArrayEquals(null, ArrayUtils.toObject(b));
3007
3008 assertSame(ArrayUtils.EMPTY_SHORT_OBJECT_ARRAY,
3009 ArrayUtils.toObject(new short[0]));
3010
3011 assertTrue(Arrays.equals(
3012 new Short[] {Short.valueOf(Short.MIN_VALUE), Short.valueOf(Short.MAX_VALUE),
3013 Short.valueOf((short)9999999)},
3014 ArrayUtils.toObject(new short[] {Short.MIN_VALUE, Short.MAX_VALUE,
3015 (short)9999999}))
3016 );
3017 }
3018
3019
3020
3021 @Test
3022 public void testToPrimitive_int() {
3023 final Integer[] b = null;
3024 assertEquals(null, ArrayUtils.toPrimitive(b));
3025 assertSame(ArrayUtils.EMPTY_INT_ARRAY, ArrayUtils.toPrimitive(new Integer[0]));
3026 assertTrue(Arrays.equals(
3027 new int[] {Integer.MIN_VALUE, Integer.MAX_VALUE, 9999999},
3028 ArrayUtils.toPrimitive(new Integer[] {Integer.valueOf(Integer.MIN_VALUE),
3029 Integer.valueOf(Integer.MAX_VALUE), Integer.valueOf(9999999)}))
3030 );
3031
3032 try {
3033 ArrayUtils.toPrimitive(new Integer[] {Integer.valueOf(Integer.MIN_VALUE), null});
3034 fail();
3035 } catch (final NullPointerException ex) {}
3036 }
3037
3038 @Test
3039 public void testToPrimitive_int_int() {
3040 final Long[] l = null;
3041 assertEquals(null, ArrayUtils.toPrimitive(l, Integer.MIN_VALUE));
3042 assertSame(ArrayUtils.EMPTY_INT_ARRAY,
3043 ArrayUtils.toPrimitive(new Integer[0], 1));
3044 assertTrue(Arrays.equals(
3045 new int[] {Integer.MIN_VALUE, Integer.MAX_VALUE, 9999999},
3046 ArrayUtils.toPrimitive(new Integer[] {Integer.valueOf(Integer.MIN_VALUE),
3047 Integer.valueOf(Integer.MAX_VALUE), Integer.valueOf(9999999)},1)));
3048 assertTrue(Arrays.equals(
3049 new int[] {Integer.MIN_VALUE, Integer.MAX_VALUE, 9999999},
3050 ArrayUtils.toPrimitive(new Integer[] {Integer.valueOf(Integer.MIN_VALUE),
3051 null, Integer.valueOf(9999999)}, Integer.MAX_VALUE))
3052 );
3053 }
3054
3055 @Test
3056 public void testToPrimitive_intNull() {
3057 final Integer[] iArray = null;
3058 assertEquals(null, ArrayUtils.toPrimitive(iArray, Integer.MIN_VALUE));
3059 }
3060
3061 @Test
3062 public void testToObject_int() {
3063 final int[] b = null;
3064 assertArrayEquals(null, ArrayUtils.toObject(b));
3065
3066 assertSame(
3067 ArrayUtils.EMPTY_INTEGER_OBJECT_ARRAY,
3068 ArrayUtils.toObject(new int[0]));
3069
3070 assertTrue(
3071 Arrays.equals(
3072 new Integer[] {
3073 Integer.valueOf(Integer.MIN_VALUE),
3074 Integer.valueOf(Integer.MAX_VALUE),
3075 Integer.valueOf(9999999)},
3076 ArrayUtils.toObject(
3077 new int[] { Integer.MIN_VALUE, Integer.MAX_VALUE, 9999999 })));
3078 }
3079
3080
3081
3082 @Test
3083 public void testToPrimitive_long() {
3084 final Long[] b = null;
3085 assertEquals(null, ArrayUtils.toPrimitive(b));
3086
3087 assertSame(ArrayUtils.EMPTY_LONG_ARRAY,
3088 ArrayUtils.toPrimitive(new Long[0]));
3089
3090 assertTrue(Arrays.equals(
3091 new long[] {Long.MIN_VALUE, Long.MAX_VALUE, 9999999},
3092 ArrayUtils.toPrimitive(new Long[] {Long.valueOf(Long.MIN_VALUE),
3093 Long.valueOf(Long.MAX_VALUE), Long.valueOf(9999999)}))
3094 );
3095
3096 try {
3097 ArrayUtils.toPrimitive(new Long[] {Long.valueOf(Long.MIN_VALUE), null});
3098 fail();
3099 } catch (final NullPointerException ex) {}
3100 }
3101
3102 @Test
3103 public void testToPrimitive_long_long() {
3104 final Long[] l = null;
3105 assertEquals(null, ArrayUtils.toPrimitive(l, Long.MIN_VALUE));
3106
3107 assertSame(ArrayUtils.EMPTY_LONG_ARRAY,
3108 ArrayUtils.toPrimitive(new Long[0], 1));
3109
3110 assertTrue(Arrays.equals(
3111 new long[] {Long.MIN_VALUE, Long.MAX_VALUE, 9999999},
3112 ArrayUtils.toPrimitive(new Long[] {Long.valueOf(Long.MIN_VALUE),
3113 Long.valueOf(Long.MAX_VALUE), Long.valueOf(9999999)},1)));
3114
3115 assertTrue(Arrays.equals(
3116 new long[] {Long.MIN_VALUE, Long.MAX_VALUE, 9999999},
3117 ArrayUtils.toPrimitive(new Long[] {Long.valueOf(Long.MIN_VALUE),
3118 null, Long.valueOf(9999999)}, Long.MAX_VALUE))
3119 );
3120 }
3121
3122 @Test
3123 public void testToObject_long() {
3124 final long[] b = null;
3125 assertArrayEquals(null, ArrayUtils.toObject(b));
3126
3127 assertSame(
3128 ArrayUtils.EMPTY_LONG_OBJECT_ARRAY,
3129 ArrayUtils.toObject(new long[0]));
3130
3131 assertTrue(
3132 Arrays.equals(
3133 new Long[] {
3134 Long.valueOf(Long.MIN_VALUE),
3135 Long.valueOf(Long.MAX_VALUE),
3136 Long.valueOf(9999999)},
3137 ArrayUtils.toObject(
3138 new long[] { Long.MIN_VALUE, Long.MAX_VALUE, 9999999 })));
3139 }
3140
3141
3142
3143 @Test
3144 public void testToPrimitive_float() {
3145 final Float[] b = null;
3146 assertEquals(null, ArrayUtils.toPrimitive(b));
3147
3148 assertSame(ArrayUtils.EMPTY_FLOAT_ARRAY,
3149 ArrayUtils.toPrimitive(new Float[0]));
3150
3151 assertTrue(Arrays.equals(
3152 new float[] {Float.MIN_VALUE, Float.MAX_VALUE, 9999999},
3153 ArrayUtils.toPrimitive(new Float[] {Float.valueOf(Float.MIN_VALUE),
3154 Float.valueOf(Float.MAX_VALUE), Float.valueOf(9999999)}))
3155 );
3156
3157 try {
3158 ArrayUtils.toPrimitive(new Float[] {Float.valueOf(Float.MIN_VALUE), null});
3159 fail();
3160 } catch (final NullPointerException ex) {}
3161 }
3162
3163 @Test
3164 public void testToPrimitive_float_float() {
3165 final Float[] l = null;
3166 assertEquals(null, ArrayUtils.toPrimitive(l, Float.MIN_VALUE));
3167
3168 assertSame(ArrayUtils.EMPTY_FLOAT_ARRAY,
3169 ArrayUtils.toPrimitive(new Float[0], 1));
3170
3171 assertTrue(Arrays.equals(
3172 new float[] {Float.MIN_VALUE, Float.MAX_VALUE, 9999999},
3173 ArrayUtils.toPrimitive(new Float[] {Float.valueOf(Float.MIN_VALUE),
3174 Float.valueOf(Float.MAX_VALUE), Float.valueOf(9999999)},1)));
3175
3176 assertTrue(Arrays.equals(
3177 new float[] {Float.MIN_VALUE, Float.MAX_VALUE, 9999999},
3178 ArrayUtils.toPrimitive(new Float[] {Float.valueOf(Float.MIN_VALUE),
3179 null, Float.valueOf(9999999)}, Float.MAX_VALUE))
3180 );
3181 }
3182
3183 @Test
3184 public void testToObject_float() {
3185 final float[] b = null;
3186 assertArrayEquals(null, ArrayUtils.toObject(b));
3187
3188 assertSame(
3189 ArrayUtils.EMPTY_FLOAT_OBJECT_ARRAY,
3190 ArrayUtils.toObject(new float[0]));
3191
3192 assertTrue(
3193 Arrays.equals(
3194 new Float[] {
3195 Float.valueOf(Float.MIN_VALUE),
3196 Float.valueOf(Float.MAX_VALUE),
3197 Float.valueOf(9999999)},
3198 ArrayUtils.toObject(
3199 new float[] { Float.MIN_VALUE, Float.MAX_VALUE, 9999999 })));
3200 }
3201
3202
3203
3204 @Test
3205 public void testToPrimitive_double() {
3206 final Double[] b = null;
3207 assertEquals(null, ArrayUtils.toPrimitive(b));
3208
3209 assertSame(ArrayUtils.EMPTY_DOUBLE_ARRAY,
3210 ArrayUtils.toPrimitive(new Double[0]));
3211
3212 assertTrue(Arrays.equals(
3213 new double[] {Double.MIN_VALUE, Double.MAX_VALUE, 9999999},
3214 ArrayUtils.toPrimitive(new Double[] {Double.valueOf(Double.MIN_VALUE),
3215 Double.valueOf(Double.MAX_VALUE), Double.valueOf(9999999)}))
3216 );
3217
3218 try {
3219 ArrayUtils.toPrimitive(new Float[] {Float.valueOf(Float.MIN_VALUE), null});
3220 fail();
3221 } catch (final NullPointerException ex) {}
3222 }
3223
3224 @Test
3225 public void testToPrimitive_double_double() {
3226 final Double[] l = null;
3227 assertEquals(null, ArrayUtils.toPrimitive(l, Double.MIN_VALUE));
3228
3229 assertSame(ArrayUtils.EMPTY_DOUBLE_ARRAY,
3230 ArrayUtils.toPrimitive(new Double[0], 1));
3231
3232 assertTrue(Arrays.equals(
3233 new double[] {Double.MIN_VALUE, Double.MAX_VALUE, 9999999},
3234 ArrayUtils.toPrimitive(new Double[] {Double.valueOf(Double.MIN_VALUE),
3235 Double.valueOf(Double.MAX_VALUE), Double.valueOf(9999999)},1)));
3236
3237 assertTrue(Arrays.equals(
3238 new double[] {Double.MIN_VALUE, Double.MAX_VALUE, 9999999},
3239 ArrayUtils.toPrimitive(new Double[] {Double.valueOf(Double.MIN_VALUE),
3240 null, Double.valueOf(9999999)}, Double.MAX_VALUE))
3241 );
3242 }
3243
3244 @Test
3245 public void testToObject_double() {
3246 final double[] b = null;
3247 assertArrayEquals(null, ArrayUtils.toObject(b));
3248
3249 assertSame(
3250 ArrayUtils.EMPTY_DOUBLE_OBJECT_ARRAY,
3251 ArrayUtils.toObject(new double[0]));
3252
3253 assertTrue(
3254 Arrays.equals(
3255 new Double[] {
3256 Double.valueOf(Double.MIN_VALUE),
3257 Double.valueOf(Double.MAX_VALUE),
3258 Double.valueOf(9999999)},
3259 ArrayUtils.toObject(
3260 new double[] { Double.MIN_VALUE, Double.MAX_VALUE, 9999999 })));
3261 }
3262
3263
3264
3265
3266
3267 @Test
3268 public void testIsEmptyObject() {
3269 final Object[] emptyArray = new Object[] {};
3270 final Object[] notEmptyArray = new Object[] { new String("Value") };
3271 assertTrue(ArrayUtils.isEmpty((Object[])null));
3272 assertTrue(ArrayUtils.isEmpty(emptyArray));
3273 assertFalse(ArrayUtils.isEmpty(notEmptyArray));
3274 }
3275
3276
3277
3278
3279
3280
3281
3282
3283
3284
3285
3286 @Test
3287 public void testIsEmptyPrimitives() {
3288 final long[] emptyLongArray = new long[] {};
3289 final long[] notEmptyLongArray = new long[] { 1L };
3290 assertTrue(ArrayUtils.isEmpty((long[])null));
3291 assertTrue(ArrayUtils.isEmpty(emptyLongArray));
3292 assertFalse(ArrayUtils.isEmpty(notEmptyLongArray));
3293
3294 final int[] emptyIntArray = new int[] {};
3295 final int[] notEmptyIntArray = new int[] { 1 };
3296 assertTrue(ArrayUtils.isEmpty((int[])null));
3297 assertTrue(ArrayUtils.isEmpty(emptyIntArray));
3298 assertFalse(ArrayUtils.isEmpty(notEmptyIntArray));
3299
3300 final short[] emptyShortArray = new short[] {};
3301 final short[] notEmptyShortArray = new short[] { 1 };
3302 assertTrue(ArrayUtils.isEmpty((short[])null));
3303 assertTrue(ArrayUtils.isEmpty(emptyShortArray));
3304 assertFalse(ArrayUtils.isEmpty(notEmptyShortArray));
3305
3306 final char[] emptyCharArray = new char[] {};
3307 final char[] notEmptyCharArray = new char[] { 1 };
3308 assertTrue(ArrayUtils.isEmpty((char[])null));
3309 assertTrue(ArrayUtils.isEmpty(emptyCharArray));
3310 assertFalse(ArrayUtils.isEmpty(notEmptyCharArray));
3311
3312 final byte[] emptyByteArray = new byte[] {};
3313 final byte[] notEmptyByteArray = new byte[] { 1 };
3314 assertTrue(ArrayUtils.isEmpty((byte[])null));
3315 assertTrue(ArrayUtils.isEmpty(emptyByteArray));
3316 assertFalse(ArrayUtils.isEmpty(notEmptyByteArray));
3317
3318 final double[] emptyDoubleArray = new double[] {};
3319 final double[] notEmptyDoubleArray = new double[] { 1.0 };
3320 assertTrue(ArrayUtils.isEmpty((double[])null));
3321 assertTrue(ArrayUtils.isEmpty(emptyDoubleArray));
3322 assertFalse(ArrayUtils.isEmpty(notEmptyDoubleArray));
3323
3324 final float[] emptyFloatArray = new float[] {};
3325 final float[] notEmptyFloatArray = new float[] { 1.0F };
3326 assertTrue(ArrayUtils.isEmpty((float[])null));
3327 assertTrue(ArrayUtils.isEmpty(emptyFloatArray));
3328 assertFalse(ArrayUtils.isEmpty(notEmptyFloatArray));
3329
3330 final boolean[] emptyBooleanArray = new boolean[] {};
3331 final boolean[] notEmptyBooleanArray = new boolean[] { true };
3332 assertTrue(ArrayUtils.isEmpty((boolean[])null));
3333 assertTrue(ArrayUtils.isEmpty(emptyBooleanArray));
3334 assertFalse(ArrayUtils.isEmpty(notEmptyBooleanArray));
3335 }
3336
3337
3338
3339
3340 @Test
3341 public void testIsNotEmptyObject() {
3342 final Object[] emptyArray = new Object[] {};
3343 final Object[] notEmptyArray = new Object[] { new String("Value") };
3344 assertFalse(ArrayUtils.isNotEmpty((Object[])null));
3345 assertFalse(ArrayUtils.isNotEmpty(emptyArray));
3346 assertTrue(ArrayUtils.isNotEmpty(notEmptyArray));
3347 }
3348
3349
3350
3351
3352
3353
3354
3355
3356
3357
3358
3359 @Test
3360 public void testIsNotEmptyPrimitives() {
3361 final long[] emptyLongArray = new long[] {};
3362 final long[] notEmptyLongArray = new long[] { 1L };
3363 assertFalse(ArrayUtils.isNotEmpty((long[])null));
3364 assertFalse(ArrayUtils.isNotEmpty(emptyLongArray));
3365 assertTrue(ArrayUtils.isNotEmpty(notEmptyLongArray));
3366
3367 final int[] emptyIntArray = new int[] {};
3368 final int[] notEmptyIntArray = new int[] { 1 };
3369 assertFalse(ArrayUtils.isNotEmpty((int[])null));
3370 assertFalse(ArrayUtils.isNotEmpty(emptyIntArray));
3371 assertTrue(ArrayUtils.isNotEmpty(notEmptyIntArray));
3372
3373 final short[] emptyShortArray = new short[] {};
3374 final short[] notEmptyShortArray = new short[] { 1 };
3375 assertFalse(ArrayUtils.isNotEmpty((short[])null));
3376 assertFalse(ArrayUtils.isNotEmpty(emptyShortArray));
3377 assertTrue(ArrayUtils.isNotEmpty(notEmptyShortArray));
3378
3379 final char[] emptyCharArray = new char[] {};
3380 final char[] notEmptyCharArray = new char[] { 1 };
3381 assertFalse(ArrayUtils.isNotEmpty((char[])null));
3382 assertFalse(ArrayUtils.isNotEmpty(emptyCharArray));
3383 assertTrue(ArrayUtils.isNotEmpty(notEmptyCharArray));
3384
3385 final byte[] emptyByteArray = new byte[] {};
3386 final byte[] notEmptyByteArray = new byte[] { 1 };
3387 assertFalse(ArrayUtils.isNotEmpty((byte[])null));
3388 assertFalse(ArrayUtils.isNotEmpty(emptyByteArray));
3389 assertTrue(ArrayUtils.isNotEmpty(notEmptyByteArray));
3390
3391 final double[] emptyDoubleArray = new double[] {};
3392 final double[] notEmptyDoubleArray = new double[] { 1.0 };
3393 assertFalse(ArrayUtils.isNotEmpty((double[])null));
3394 assertFalse(ArrayUtils.isNotEmpty(emptyDoubleArray));
3395 assertTrue(ArrayUtils.isNotEmpty(notEmptyDoubleArray));
3396
3397 final float[] emptyFloatArray = new float[] {};
3398 final float[] notEmptyFloatArray = new float[] { 1.0F };
3399 assertFalse(ArrayUtils.isNotEmpty((float[])null));
3400 assertFalse(ArrayUtils.isNotEmpty(emptyFloatArray));
3401 assertTrue(ArrayUtils.isNotEmpty(notEmptyFloatArray));
3402
3403 final boolean[] emptyBooleanArray = new boolean[] {};
3404 final boolean[] notEmptyBooleanArray = new boolean[] { true };
3405 assertFalse(ArrayUtils.isNotEmpty((boolean[])null));
3406 assertFalse(ArrayUtils.isNotEmpty(emptyBooleanArray));
3407 assertTrue(ArrayUtils.isNotEmpty(notEmptyBooleanArray));
3408 }
3409
3410 @Test
3411 public void testGetLength() {
3412 assertEquals(0, ArrayUtils.getLength(null));
3413
3414 final Object[] emptyObjectArray = new Object[0];
3415 final Object[] notEmptyObjectArray = new Object[] {"aValue"};
3416 assertEquals(0, ArrayUtils.getLength((Object[]) null));
3417 assertEquals(0, ArrayUtils.getLength(emptyObjectArray));
3418 assertEquals(1, ArrayUtils.getLength(notEmptyObjectArray));
3419
3420 final int[] emptyIntArray = new int[] {};
3421 final int[] notEmptyIntArray = new int[] { 1 };
3422 assertEquals(0, ArrayUtils.getLength((int[]) null));
3423 assertEquals(0, ArrayUtils.getLength(emptyIntArray));
3424 assertEquals(1, ArrayUtils.getLength(notEmptyIntArray));
3425
3426 final short[] emptyShortArray = new short[] {};
3427 final short[] notEmptyShortArray = new short[] { 1 };
3428 assertEquals(0, ArrayUtils.getLength((short[]) null));
3429 assertEquals(0, ArrayUtils.getLength(emptyShortArray));
3430 assertEquals(1, ArrayUtils.getLength(notEmptyShortArray));
3431
3432 final char[] emptyCharArray = new char[] {};
3433 final char[] notEmptyCharArray = new char[] { 1 };
3434 assertEquals(0, ArrayUtils.getLength((char[]) null));
3435 assertEquals(0, ArrayUtils.getLength(emptyCharArray));
3436 assertEquals(1, ArrayUtils.getLength(notEmptyCharArray));
3437
3438 final byte[] emptyByteArray = new byte[] {};
3439 final byte[] notEmptyByteArray = new byte[] { 1 };
3440 assertEquals(0, ArrayUtils.getLength((byte[]) null));
3441 assertEquals(0, ArrayUtils.getLength(emptyByteArray));
3442 assertEquals(1, ArrayUtils.getLength(notEmptyByteArray));
3443
3444 final double[] emptyDoubleArray = new double[] {};
3445 final double[] notEmptyDoubleArray = new double[] { 1.0 };
3446 assertEquals(0, ArrayUtils.getLength((double[]) null));
3447 assertEquals(0, ArrayUtils.getLength(emptyDoubleArray));
3448 assertEquals(1, ArrayUtils.getLength(notEmptyDoubleArray));
3449
3450 final float[] emptyFloatArray = new float[] {};
3451 final float[] notEmptyFloatArray = new float[] { 1.0F };
3452 assertEquals(0, ArrayUtils.getLength((float[]) null));
3453 assertEquals(0, ArrayUtils.getLength(emptyFloatArray));
3454 assertEquals(1, ArrayUtils.getLength(notEmptyFloatArray));
3455
3456 final boolean[] emptyBooleanArray = new boolean[] {};
3457 final boolean[] notEmptyBooleanArray = new boolean[] { true };
3458 assertEquals(0, ArrayUtils.getLength((boolean[]) null));
3459 assertEquals(0, ArrayUtils.getLength(emptyBooleanArray));
3460 assertEquals(1, ArrayUtils.getLength(notEmptyBooleanArray));
3461
3462 try {
3463 ArrayUtils.getLength("notAnArray");
3464 fail("IllegalArgumentException should have been thrown");
3465 } catch (final IllegalArgumentException e) {}
3466 }
3467
3468 @Test
3469 public void testIsSorted() {
3470 Integer[] array = null;
3471 assertTrue(ArrayUtils.isSorted(array));
3472
3473 array = new Integer[]{1};
3474 assertTrue(ArrayUtils.isSorted(array));
3475
3476 array = new Integer[]{1,2,3};
3477 assertTrue(ArrayUtils.isSorted(array));
3478
3479 array = new Integer[]{1,3,2};
3480 assertFalse(ArrayUtils.isSorted(array));
3481 }
3482
3483 @Test
3484 public void testIsSortedComparator() {
3485 Comparator<Integer> c = new Comparator<Integer>() {
3486 public int compare(Integer o1, Integer o2) {
3487 return o2.compareTo(o1);
3488 }
3489 };
3490
3491 Integer[] array = null;
3492 assertTrue(ArrayUtils.isSorted(array, c));
3493
3494 array = new Integer[]{1};
3495 assertTrue(ArrayUtils.isSorted(array, c));
3496
3497 array = new Integer[]{3,2,1};
3498 assertTrue(ArrayUtils.isSorted(array, c));
3499
3500 array = new Integer[]{1,3,2};
3501 assertFalse(ArrayUtils.isSorted(array, c));
3502 }
3503
3504 @Test(expected = IllegalArgumentException.class)
3505 public void testIsSortedNullComparator() throws Exception {
3506 ArrayUtils.isSorted(null, null);
3507 }
3508
3509 @Test
3510 public void testIsSortedInt() {
3511 int[] array = null;
3512 assertTrue(ArrayUtils.isSorted(array));
3513
3514 array = new int[]{1};
3515 assertTrue(ArrayUtils.isSorted(array));
3516
3517 array = new int[]{1,2,3};
3518 assertTrue(ArrayUtils.isSorted(array));
3519
3520 array = new int[]{1,3,2};
3521 assertFalse(ArrayUtils.isSorted(array));
3522 }
3523
3524 @Test
3525 public void testIsSortedFloat() {
3526 float[] array = null;
3527 assertTrue(ArrayUtils.isSorted(array));
3528
3529 array = new float[]{0f};
3530 assertTrue(ArrayUtils.isSorted(array));
3531
3532 array = new float[]{-1f, 0f, 0.1f, 0.2f};
3533 assertTrue(ArrayUtils.isSorted(array));
3534
3535 array = new float[]{-1f, 0.2f, 0.1f, 0f};
3536 assertFalse(ArrayUtils.isSorted(array));
3537 }
3538
3539 @Test
3540 public void testIsSortedLong() {
3541 long[] array = null;
3542 assertTrue(ArrayUtils.isSorted(array));
3543
3544 array = new long[]{0L};
3545 assertTrue(ArrayUtils.isSorted(array));
3546
3547 array = new long[]{-1L, 0L, 1L};
3548 assertTrue(ArrayUtils.isSorted(array));
3549
3550 array = new long[]{-1L, 1L, 0L};
3551 assertFalse(ArrayUtils.isSorted(array));
3552 }
3553
3554 @Test
3555 public void testIsSortedDouble() {
3556 double[] array = null;
3557 assertTrue(ArrayUtils.isSorted(array));
3558
3559 array = new double[]{0.0};
3560 assertTrue(ArrayUtils.isSorted(array));
3561
3562 array = new double[]{-1.0, 0.0, 0.1, 0.2};
3563 assertTrue(ArrayUtils.isSorted(array));
3564
3565 array = new double[]{-1.0, 0.2, 0.1, 0.0};
3566 assertFalse(ArrayUtils.isSorted(array));
3567 }
3568
3569 @Test
3570 public void testIsSortedChar() {
3571 char[] array = null;
3572 assertTrue(ArrayUtils.isSorted(array));
3573
3574 array = new char[]{'a'};
3575 assertTrue(ArrayUtils.isSorted(array));
3576
3577 array = new char[]{'a', 'b', 'c'};
3578 assertTrue(ArrayUtils.isSorted(array));
3579
3580 array = new char[]{'a', 'c', 'b'};
3581 assertFalse(ArrayUtils.isSorted(array));
3582 }
3583
3584 @Test
3585 public void testIsSortedByte() {
3586 byte[] array = null;
3587 assertTrue(ArrayUtils.isSorted(array));
3588
3589 array = new byte[]{0x10};
3590 assertTrue(ArrayUtils.isSorted(array));
3591
3592 array = new byte[]{0x10, 0x20, 0x30};
3593 assertTrue(ArrayUtils.isSorted(array));
3594
3595 array = new byte[]{0x10, 0x30, 0x20};
3596 assertFalse(ArrayUtils.isSorted(array));
3597 }
3598
3599 @Test
3600 public void testIsSortedShort() {
3601 short[] array = null;
3602 assertTrue(ArrayUtils.isSorted(array));
3603
3604 array = new short[]{0};
3605 assertTrue(ArrayUtils.isSorted(array));
3606
3607 array = new short[]{-1, 0, 1};
3608 assertTrue(ArrayUtils.isSorted(array));
3609
3610 array = new short[]{-1, 1, 0};
3611 assertFalse(ArrayUtils.isSorted(array));
3612 }
3613
3614 @Test
3615 public void testIsSortedBool() {
3616 boolean[] array = null;
3617 assertTrue(ArrayUtils.isSorted(array));
3618
3619 array = new boolean[]{true};
3620 assertTrue(ArrayUtils.isSorted(array));
3621
3622 array = new boolean[]{false, true};
3623 assertTrue(ArrayUtils.isSorted(array));
3624
3625 array = new boolean[]{true, false};
3626 assertFalse(ArrayUtils.isSorted(array));
3627 }
3628
3629 }